70 files changed, 14011 insertions, 2765 deletions

diff --git a/security/Kconfig b/security/Kconfig
index e0f08b52e4a..85923b649d1 100644
--- a/security/Kconfig
+++ b/security/Kconfig
@@ -185,6 +185,7 @@ source security/selinux/Kconfig
 source security/smack/Kconfig
 source security/tomoyo/Kconfig
 source security/apparmor/Kconfig
+source security/tf_driver/Kconfig
 
 source security/integrity/ima/Kconfig
 
diff --git a/security/Makefile b/security/Makefile
index 8bb0fe9e1ca..9962092f065 100644
--- a/security/Makefile
+++ b/security/Makefile
@@ -7,6 +7,7 @@ subdir-$(CONFIG_SECURITY_SELINUX)	+= selinux
 subdir-$(CONFIG_SECURITY_SMACK)         += smack
 subdir-$(CONFIG_SECURITY_TOMOYO)        += tomoyo
 subdir-$(CONFIG_SECURITY_APPARMOR)      += apparmor
+subdir-$(CONFIG_TRUSTED_FOUNDATIONS)    += tf_driver
 
 # always enable default capabilities
 obj-y                                   += commoncap.o
@@ -22,6 +23,7 @@ obj-$(CONFIG_AUDIT)			+= lsm_audit.o
 obj-$(CONFIG_SECURITY_TOMOYO)           += tomoyo/built-in.o
 obj-$(CONFIG_SECURITY_APPARMOR)         += apparmor/built-in.o
 obj-$(CONFIG_CGROUP_DEVICE)             += device_cgroup.o
+obj-$(CONFIG_TRUSTED_FOUNDATIONS)       += tf_driver/built-in.o
 
 # Object integrity file lists
 subdir-$(CONFIG_IMA)                    += integrity/ima
diff --git a/security/apparmor/.gitignore b/security/apparmor/.gitignore
index 4d995aeaebc..9cdec70d72b 100644
--- a/security/apparmor/.gitignore
+++ b/security/apparmor/.gitignore
@@ -1,6 +1,5 @@
 #
 # Generated include files
 #
-af_names.h
 capability_names.h
 rlim_names.h
diff --git a/security/apparmor/domain.c b/security/apparmor/domain.c
index c825c6e0b63..c1e18ba5bdc 100644
--- a/security/apparmor/domain.c
+++ b/security/apparmor/domain.c
@@ -67,13 +67,12 @@ static int may_change_ptraced_domain(struct task_struct *task,
         int error = 0;
 
         rcu_read_lock();
-        tracer = tracehook_tracer_task(task);
+        tracer = ptrace_parent(task);
         if (tracer) {
                 /* released below */
                 cred = get_task_cred(tracer);
                 tracerp = aa_cred_profile(cred);
         }
-        rcu_read_unlock();
 
         /* not ptraced */
         if (!tracer || unconfined(tracerp))
@@ -82,6 +81,7 @@ static int may_change_ptraced_domain(struct task_struct *task,
         error = aa_may_ptrace(tracer, tracerp, to_profile, PTRACE_MODE_ATTACH);
 
 out:
+        rcu_read_unlock();
         if (cred)
                 put_cred(cred);
 
diff --git a/security/apparmor/lib.c b/security/apparmor/lib.c
index 506d2baf614..b82e383beb7 100644
--- a/security/apparmor/lib.c
+++ b/security/apparmor/lib.c
@@ -12,6 +12,7 @@
  * License.
  */
 
+#include <linux/mm.h>
 #include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/vmalloc.h>
diff --git a/security/apparmor/lsm.c b/security/apparmor/lsm.c
index 3d2fd141dff..37832026e58 100644
--- a/security/apparmor/lsm.c
+++ b/security/apparmor/lsm.c
@@ -127,7 +127,7 @@ static int apparmor_capget(struct task_struct *target, kernel_cap_t *effective,
         *inheritable = cred->cap_inheritable;
         *permitted = cred->cap_permitted;
 
-        if (!unconfined(profile)) {
+        if (!unconfined(profile) && !COMPLAIN_MODE(profile)) {
                 *effective = cap_intersect(*effective, profile->caps.allow);
                 *permitted = cap_intersect(*permitted, profile->caps.allow);
         }
diff --git a/security/apparmor/path.c b/security/apparmor/path.c
index 36cc0cc39e7..b566eba4a65 100644
--- a/security/apparmor/path.c
+++ b/security/apparmor/path.c
@@ -57,23 +57,44 @@ static int prepend(char **buffer, int buflen, const char *str, int namelen)
 static int d_namespace_path(struct path *path, char *buf, int buflen,
                             char **name, int flags)
 {
-        struct path root, tmp;
         char *res;
-        int connected, error = 0;
+        int error = 0;
+        int connected = 1;
+
+        if (path->mnt->mnt_flags & MNT_INTERNAL) {
+                /* it's not mounted anywhere */
+                res = dentry_path(path->dentry, buf, buflen);
+                *name = res;
+                if (IS_ERR(res)) {
+                        *name = buf;
+                        return PTR_ERR(res);
+                }
+                if (path->dentry->d_sb->s_magic == PROC_SUPER_MAGIC &&
+                    strncmp(*name, "/sys/", 5) == 0) {
+                        /* TODO: convert over to using a per namespace
+                         * control instead of hard coded /proc
+                         */
+                        return prepend(name, *name - buf, "/proc", 5);
+                }
+                return 0;
+        }
 
-        /* Get the root we want to resolve too, released below */
+        /* resolve paths relative to chroot?*/
         if (flags & PATH_CHROOT_REL) {
-                /* resolve paths relative to chroot */
+                struct path root;
                 get_fs_root(current->fs, &root);
-        } else {
-                /* resolve paths relative to namespace */
-                root.mnt = current->nsproxy->mnt_ns->root;
-                root.dentry = root.mnt->mnt_root;
-                path_get(&root);
+                res = __d_path(path, &root, buf, buflen);
+                if (res && !IS_ERR(res)) {
+                        /* everything's fine */
+                        *name = res;
+                        path_put(&root);
+                        goto ok;
+                }
+                path_put(&root);
+                connected = 0;
         }
 
-        tmp = root;
-        res = __d_path(path, &tmp, buf, buflen);
+        res = d_absolute_path(path, buf, buflen);
 
         *name = res;
         /* handle error conditions - and still allow a partial path to
@@ -84,7 +105,10 @@ static int d_namespace_path(struct path *path, char *buf, int buflen,
                 *name = buf;
                 goto out;
         }
+        if (!our_mnt(path->mnt))
+                connected = 0;
 
+ok:
         /* Handle two cases:
          * 1. A deleted dentry && profile is not allowing mediation of deleted
          * 2. On some filesystems, newly allocated dentries appear to the
@@ -97,10 +121,7 @@ static int d_namespace_path(struct path *path, char *buf, int buflen,
                         goto out;
         }
 
-        /* Determine if the path is connected to the expected root */
-        connected = tmp.dentry == root.dentry && tmp.mnt == root.mnt;
-
-        /* If the path is not connected,
+        /* If the path is not connected to the expected root,
          * check if it is a sysctl and handle specially else remove any
          * leading / that __d_path may have returned.
          * Unless
@@ -112,17 +133,9 @@ static int d_namespace_path(struct path *path, char *buf, int buflen,
          *     namespace root.
          */
         if (!connected) {
-                /* is the disconnect path a sysctl? */
-                if (tmp.dentry->d_sb->s_magic == PROC_SUPER_MAGIC &&
-                    strncmp(*name, "/sys/", 5) == 0) {
-                        /* TODO: convert over to using a per namespace
-                         * control instead of hard coded /proc
-                         */
-                        error = prepend(name, *name - buf, "/proc", 5);
-                } else if (!(flags & PATH_CONNECT_PATH) &&
+                if (!(flags & PATH_CONNECT_PATH) &&
                            !(((flags & CHROOT_NSCONNECT) == CHROOT_NSCONNECT) &&
-                             (tmp.mnt == current->nsproxy->mnt_ns->root &&
-                              tmp.dentry == tmp.mnt->mnt_root))) {
+                             our_mnt(path->mnt))) {
                         /* disconnected path, don't return pathname starting
                          * with '/'
                          */
@@ -133,8 +146,6 @@ static int d_namespace_path(struct path *path, char *buf, int buflen,
         }
 
 out:
-        path_put(&root);
-
         return error;
 }
 
diff --git a/security/capability.c b/security/capability.c
index bbb51156261..2984ea4f776 100644
--- a/security/capability.c
+++ b/security/capability.c
@@ -181,7 +181,7 @@ static int cap_inode_follow_link(struct dentry *dentry,
         return 0;
 }
 
-static int cap_inode_permission(struct inode *inode, int mask, unsigned flags)
+static int cap_inode_permission(struct inode *inode, int mask)
 {
         return 0;
 }
diff --git a/security/commoncap.c b/security/commoncap.c
index a93b3b73307..e508e2b170a 100644
--- a/security/commoncap.c
+++ b/security/commoncap.c
@@ -29,6 +29,10 @@
 #include <linux/securebits.h>
 #include <linux/user_namespace.h>
 
+#ifdef CONFIG_ANDROID_PARANOID_NETWORK
+#include <linux/android_aid.h>
+#endif
+
 /*
  * If a non-root user executes a setuid-root binary in
  * !secure(SECURE_NOROOT) mode, then we raise capabilities.
@@ -83,6 +87,12 @@ EXPORT_SYMBOL(cap_netlink_recv);
 int cap_capable(struct task_struct *tsk, const struct cred *cred,
                 struct user_namespace *targ_ns, int cap, int audit)
 {
+#ifdef CONFIG_ANDROID_PARANOID_NETWORK
+        if (cap == CAP_NET_RAW && in_egroup_p(AID_NET_RAW))
+                return 0;
+        if (cap == CAP_NET_ADMIN && in_egroup_p(AID_NET_ADMIN))
+                return 0;
+#endif
         for (;;) {
                 /* The creator of the user namespace has all caps. */
                 if (targ_ns != &init_user_ns && targ_ns->creator == cred->user)
diff --git a/security/device_cgroup.c b/security/device_cgroup.c
index 1be68269e1c..4450fbeec41 100644
--- a/security/device_cgroup.c
+++ b/security/device_cgroup.c
@@ -125,14 +125,6 @@ static int dev_whitelist_add(struct dev_cgroup *dev_cgroup,
         return 0;
 }
 
-static void whitelist_item_free(struct rcu_head *rcu)
-{
-        struct dev_whitelist_item *item;
-
-        item = container_of(rcu, struct dev_whitelist_item, rcu);
-        kfree(item);
-}
-
 /*
  * called under devcgroup_mutex
  */
@@ -155,7 +147,7 @@ remove:
                 walk->access &= ~wh->access;
                 if (!walk->access) {
                         list_del_rcu(&walk->list);
-                        call_rcu(&walk->rcu, whitelist_item_free);
+                        kfree_rcu(walk, rcu);
                 }
         }
 }
diff --git a/security/integrity/ima/ima_api.c b/security/integrity/ima/ima_api.c
index da36d2c085a..5335605571f 100644
--- a/security/integrity/ima/ima_api.c
+++ b/security/integrity/ima/ima_api.c
@@ -177,8 +177,8 @@ void ima_store_measurement(struct ima_iint_cache *iint, struct file *file,
         strncpy(entry->template.file_name, filename, IMA_EVENT_NAME_LEN_MAX);
 
         result = ima_store_template(entry, violation, inode);
-        if (!result)
+        if (!result || result == -EEXIST)
                 iint->flags |= IMA_MEASURED;
-        else
+        if (result < 0)
                 kfree(entry);
 }
diff --git a/security/integrity/ima/ima_main.c b/security/integrity/ima/ima_main.c
index 39d66dc2b8e..26b46ff7466 100644
--- a/security/integrity/ima/ima_main.c
+++ b/security/integrity/ima/ima_main.c
@@ -86,7 +86,7 @@ static void ima_check_last_writer(struct ima_iint_cache *iint,
                                   struct inode *inode,
                                   struct file *file)
 {
-        mode_t mode = file->f_mode;
+        fmode_t mode = file->f_mode;
 
         mutex_lock(&iint->mutex);
         if (mode & FMODE_WRITE &&
diff --git a/security/integrity/ima/ima_queue.c b/security/integrity/ima/ima_queue.c
index 8e28f04a5e2..55a6271bce7 100644
--- a/security/integrity/ima/ima_queue.c
+++ b/security/integrity/ima/ima_queue.c
@@ -23,6 +23,8 @@
 #include <linux/slab.h>
 #include "ima.h"
 
+#define AUDIT_CAUSE_LEN_MAX 32
+
 LIST_HEAD(ima_measurements);    /* list of all measurements */
 
 /* key: inode (before secure-hashing a file) */
@@ -94,7 +96,8 @@ static int ima_pcr_extend(const u8 *hash)
 
         result = tpm_pcr_extend(TPM_ANY_NUM, CONFIG_IMA_MEASURE_PCR_IDX, hash);
         if (result != 0)
-                pr_err("IMA: Error Communicating to TPM chip\n");
+                pr_err("IMA: Error Communicating to TPM chip, result: %d\n",
+                       result);
         return result;
 }
 
@@ -106,14 +109,16 @@ int ima_add_template_entry(struct ima_template_entry *entry, int violation,
 {
         u8 digest[IMA_DIGEST_SIZE];
         const char *audit_cause = "hash_added";
+        char tpm_audit_cause[AUDIT_CAUSE_LEN_MAX];
         int audit_info = 1;
-        int result = 0;
+        int result = 0, tpmresult = 0;
 
         mutex_lock(&ima_extend_list_mutex);
         if (!violation) {
                 memcpy(digest, entry->digest, sizeof digest);
                 if (ima_lookup_digest_entry(digest)) {
                         audit_cause = "hash_exists";
+                        result = -EEXIST;
                         goto out;
                 }
         }
@@ -128,9 +133,11 @@ int ima_add_template_entry(struct ima_template_entry *entry, int violation,
         if (violation)          /* invalidate pcr */
                 memset(digest, 0xff, sizeof digest);
 
-        result = ima_pcr_extend(digest);
-        if (result != 0) {
-                audit_cause = "TPM error";
+        tpmresult = ima_pcr_extend(digest);
+        if (tpmresult != 0) {
+                snprintf(tpm_audit_cause, AUDIT_CAUSE_LEN_MAX, "TPM_error(%d)",
+                         tpmresult);
+                audit_cause = tpm_audit_cause;
                 audit_info = 0;
         }
 out:
diff --git a/security/keys/Makefile b/security/keys/Makefile
index 1bf090a885f..b34cc6ee690 100644
--- a/security/keys/Makefile
+++ b/security/keys/Makefile
@@ -14,7 +14,7 @@ obj-y := \
         user_defined.o
 
 obj-$(CONFIG_TRUSTED_KEYS) += trusted.o
-obj-$(CONFIG_ENCRYPTED_KEYS) += encrypted.o
+obj-$(CONFIG_ENCRYPTED_KEYS) += ecryptfs_format.o encrypted.o
 obj-$(CONFIG_KEYS_COMPAT) += compat.o
 obj-$(CONFIG_PROC_FS) += proc.o
 obj-$(CONFIG_SYSCTL) += sysctl.o
diff --git a/security/keys/ecryptfs_format.c b/security/keys/ecryptfs_format.c
new file mode 100644
index 00000000000..6daa3b6ff9e
--- /dev/null
+++ b/security/keys/ecryptfs_format.c
@@ -0,0 +1,81 @@
+/*
+ * ecryptfs_format.c: helper functions for the encrypted key type
+ *
+ * Copyright (C) 2006 International Business Machines Corp.
+ * Copyright (C) 2010 Politecnico di Torino, Italy
+ *                    TORSEC group -- http://security.polito.it
+ *
+ * Authors:
+ * Michael A. Halcrow <mahalcro@us.ibm.com>
+ * Tyler Hicks <tyhicks@ou.edu>
+ * Roberto Sassu <roberto.sassu@polito.it>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 2 of the License.
+ */
+
+#include <linux/module.h>
+#include "ecryptfs_format.h"
+
+u8 *ecryptfs_get_auth_tok_key(struct ecryptfs_auth_tok *auth_tok)
+{
+        return auth_tok->token.password.session_key_encryption_key;
+}
+EXPORT_SYMBOL(ecryptfs_get_auth_tok_key);
+
+/*
+ * ecryptfs_get_versions()
+ *
+ * Source code taken from the software 'ecryptfs-utils' version 83.
+ *
+ */
+void ecryptfs_get_versions(int *major, int *minor, int *file_version)
+{
+        *major = ECRYPTFS_VERSION_MAJOR;
+        *minor = ECRYPTFS_VERSION_MINOR;
+        if (file_version)
+                *file_version = ECRYPTFS_SUPPORTED_FILE_VERSION;
+}
+EXPORT_SYMBOL(ecryptfs_get_versions);
+
+/*
+ * ecryptfs_fill_auth_tok - fill the ecryptfs_auth_tok structure
+ *
+ * Fill the ecryptfs_auth_tok structure with required ecryptfs data.
+ * The source code is inspired to the original function generate_payload()
+ * shipped with the software 'ecryptfs-utils' version 83.
+ *
+ */
+int ecryptfs_fill_auth_tok(struct ecryptfs_auth_tok *auth_tok,
+                           const char *key_desc)
+{
+        int major, minor;
+
+        ecryptfs_get_versions(&major, &minor, NULL);
+        auth_tok->version = (((uint16_t)(major << 8) & 0xFF00)
+                             | ((uint16_t)minor & 0x00FF));
+        auth_tok->token_type = ECRYPTFS_PASSWORD;
+        strncpy((char *)auth_tok->token.password.signature, key_desc,
+                ECRYPTFS_PASSWORD_SIG_SIZE);
+        auth_tok->token.password.session_key_encryption_key_bytes =
+                ECRYPTFS_MAX_KEY_BYTES;
+        /*
+         * Removed auth_tok->token.password.salt and
+         * auth_tok->token.password.session_key_encryption_key
+         * initialization from the original code
+         */
+        /* TODO: Make the hash parameterizable via policy */
+        auth_tok->token.password.flags |=
+                ECRYPTFS_SESSION_KEY_ENCRYPTION_KEY_SET;
+        /* The kernel code will encrypt the session key. */
+        auth_tok->session_key.encrypted_key[0] = 0;
+        auth_tok->session_key.encrypted_key_size = 0;
+        /* Default; subject to change by kernel eCryptfs */
+        auth_tok->token.password.hash_algo = PGP_DIGEST_ALGO_SHA512;
+        auth_tok->token.password.flags &= ~(ECRYPTFS_PERSISTENT_PASSWORD);
+        return 0;
+}
+EXPORT_SYMBOL(ecryptfs_fill_auth_tok);
+
+MODULE_LICENSE("GPL");
diff --git a/security/keys/ecryptfs_format.h b/security/keys/ecryptfs_format.h
new file mode 100644
index 00000000000..40294de238b
--- /dev/null
+++ b/security/keys/ecryptfs_format.h
@@ -0,0 +1,30 @@
+/*
+ * ecryptfs_format.h: helper functions for the encrypted key type
+ *
+ * Copyright (C) 2006 International Business Machines Corp.
+ * Copyright (C) 2010 Politecnico di Torino, Italy
+ *                    TORSEC group -- http://security.polito.it
+ *
+ * Authors:
+ * Michael A. Halcrow <mahalcro@us.ibm.com>
+ * Tyler Hicks <tyhicks@ou.edu>
+ * Roberto Sassu <roberto.sassu@polito.it>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 2 of the License.
+ */
+
+#ifndef __KEYS_ECRYPTFS_H
+#define __KEYS_ECRYPTFS_H
+
+#include <linux/ecryptfs.h>
+
+#define PGP_DIGEST_ALGO_SHA512   10
+
+u8 *ecryptfs_get_auth_tok_key(struct ecryptfs_auth_tok *auth_tok);
+void ecryptfs_get_versions(int *major, int *minor, int *file_version);
+int ecryptfs_fill_auth_tok(struct ecryptfs_auth_tok *auth_tok,
+                           const char *key_desc);
+
+#endif /* __KEYS_ECRYPTFS_H */
diff --git a/security/keys/encrypted.c b/security/keys/encrypted.c
index b1cba5bf0a5..e7eca9ec4c6 100644
--- a/security/keys/encrypted.c
+++ b/security/keys/encrypted.c
@@ -1,8 +1,11 @@
 /*
  * Copyright (C) 2010 IBM Corporation
+ * Copyright (C) 2010 Politecnico di Torino, Italy
+ *                    TORSEC group -- http://security.polito.it
  *
- * Author:
+ * Authors:
  * Mimi Zohar <zohar@us.ibm.com>
+ * Roberto Sassu <roberto.sassu@polito.it>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -26,22 +29,27 @@
 #include <linux/rcupdate.h>
 #include <linux/scatterlist.h>
 #include <linux/crypto.h>
+#include <linux/ctype.h>
 #include <crypto/hash.h>
 #include <crypto/sha.h>
 #include <crypto/aes.h>
 
 #include "encrypted.h"
+#include "ecryptfs_format.h"
 
 static const char KEY_TRUSTED_PREFIX[] = "trusted:";
 static const char KEY_USER_PREFIX[] = "user:";
 static const char hash_alg[] = "sha256";
 static const char hmac_alg[] = "hmac(sha256)";
 static const char blkcipher_alg[] = "cbc(aes)";
+static const char key_format_default[] = "default";
+static const char key_format_ecryptfs[] = "ecryptfs";
 static unsigned int ivsize;
 static int blksize;
 
 #define KEY_TRUSTED_PREFIX_LEN (sizeof (KEY_TRUSTED_PREFIX) - 1)
 #define KEY_USER_PREFIX_LEN (sizeof (KEY_USER_PREFIX) - 1)
+#define KEY_ECRYPTFS_DESC_LEN 16
 #define HASH_SIZE SHA256_DIGEST_SIZE
 #define MAX_DATA_SIZE 4096
 #define MIN_DATA_SIZE  20
@@ -58,6 +66,16 @@ enum {
         Opt_err = -1, Opt_new, Opt_load, Opt_update
 };
 
+enum {
+        Opt_error = -1, Opt_default, Opt_ecryptfs
+};
+
+static const match_table_t key_format_tokens = {
+        {Opt_default, "default"},
+        {Opt_ecryptfs, "ecryptfs"},
+        {Opt_error, NULL}
+};
+
 static const match_table_t key_tokens = {
         {Opt_new, "new"},
         {Opt_load, "load"},
@@ -82,9 +100,37 @@ static int aes_get_sizes(void)
 }
 
 /*
+ * valid_ecryptfs_desc - verify the description of a new/loaded encrypted key
+ *
+ * The description of a encrypted key with format 'ecryptfs' must contain
+ * exactly 16 hexadecimal characters.
+ *
+ */
+static int valid_ecryptfs_desc(const char *ecryptfs_desc)
+{
+        int i;
+
+        if (strlen(ecryptfs_desc) != KEY_ECRYPTFS_DESC_LEN) {
+                pr_err("encrypted_key: key description must be %d hexadecimal "
+                       "characters long\n", KEY_ECRYPTFS_DESC_LEN);
+                return -EINVAL;
+        }
+
+        for (i = 0; i < KEY_ECRYPTFS_DESC_LEN; i++) {
+                if (!isxdigit(ecryptfs_desc[i])) {
+                        pr_err("encrypted_key: key description must contain "
+                               "only hexadecimal characters\n");
+                        return -EINVAL;
+                }
+        }
+
+        return 0;
+}
+
+/*
  * valid_master_desc - verify the 'key-type:desc' of a new/updated master-key
  *
- * key-type:= "trusted:" | "encrypted:"
+ * key-type:= "trusted:" | "user:"
  * desc:= master-key description
  *
  * Verify that 'key-type' is valid and that 'desc' exists. On key update,
@@ -118,8 +164,9 @@ out:
  * datablob_parse - parse the keyctl data
  *
  * datablob format:
- * new <master-key name> <decrypted data length>
- * load <master-key name> <decrypted data length> <encrypted iv + data>
+ * new [<format>] <master-key name> <decrypted data length>
+ * load [<format>] <master-key name> <decrypted data length>
+ *     <encrypted iv + data>
  * update <new-master-key name>
  *
  * Tokenizes a copy of the keyctl data, returning a pointer to each token,
@@ -127,52 +174,95 @@ out:
  *
  * On success returns 0, otherwise -EINVAL.
  */
-static int datablob_parse(char *datablob, char **master_desc,
-                          char **decrypted_datalen, char **hex_encoded_iv)
+static int datablob_parse(char *datablob, const char **format,
+                          char **master_desc, char **decrypted_datalen,
+                          char **hex_encoded_iv)
 {
         substring_t args[MAX_OPT_ARGS];
         int ret = -EINVAL;
         int key_cmd;
-        char *p;
+        int key_format;
+        char *p, *keyword;
+
+        keyword = strsep(&datablob, " \t");
+        if (!keyword) {
+                pr_info("encrypted_key: insufficient parameters specified\n");
+                return ret;
+        }
+        key_cmd = match_token(keyword, key_tokens, args);
 
+        /* Get optional format: default | ecryptfs */
         p = strsep(&datablob, " \t");
-        if (!p)
+        if (!p) {
+                pr_err("encrypted_key: insufficient parameters specified\n");
                 return ret;
-        key_cmd = match_token(p, key_tokens, args);
+        }
 
-        *master_desc = strsep(&datablob, " \t");
-        if (!*master_desc)
+        key_format = match_token(p, key_format_tokens, args);
+        switch (key_format) {
+        case Opt_ecryptfs:
+        case Opt_default:
+                *format = p;
+                *master_desc = strsep(&datablob, " \t");
+                break;
+        case Opt_error:
+                *master_desc = p;
+                break;
+        }
+
+        if (!*master_desc) {
+                pr_info("encrypted_key: master key parameter is missing\n");
                 goto out;
+        }
 
-        if (valid_master_desc(*master_desc, NULL) < 0)
+        if (valid_master_desc(*master_desc, NULL) < 0) {
+                pr_info("encrypted_key: master key parameter \'%s\' "
+                        "is invalid\n", *master_desc);
                 goto out;
+        }
 
         if (decrypted_datalen) {
                 *decrypted_datalen = strsep(&datablob, " \t");
-                if (!*decrypted_datalen)
+                if (!*decrypted_datalen) {
+                        pr_info("encrypted_key: keylen parameter is missing\n");
                         goto out;
+                }
         }
 
         switch (key_cmd) {
         case Opt_new:
-                if (!decrypted_datalen)
+                if (!decrypted_datalen) {
+                        pr_info("encrypted_key: keyword \'%s\' not allowed "
+                                "when called from .update method\n", keyword);
                         break;
+                }
                 ret = 0;
                 break;
         case Opt_load:
-                if (!decrypted_datalen)
+                if (!decrypted_datalen) {
+                        pr_info("encrypted_key: keyword \'%s\' not allowed "
+                                "when called from .update method\n", keyword);
                         break;
+                }
                 *hex_encoded_iv = strsep(&datablob, " \t");
-                if (!*hex_encoded_iv)
+                if (!*hex_encoded_iv) {
+                        pr_info("encrypted_key: hex blob is missing\n");
                         break;
+                }
                 ret = 0;
                 break;
         case Opt_update:
-                if (decrypted_datalen)
+                if (decrypted_datalen) {
+                        pr_info("encrypted_key: keyword \'%s\' not allowed "
+                                "when called from .instantiate method\n",
+                                keyword);
                         break;
+                }
                 ret = 0;
                 break;
         case Opt_err:
+                pr_info("encrypted_key: keyword \'%s\' not recognized\n",
+                        keyword);
                 break;
         }
 out:
@@ -197,8 +287,8 @@ static char *datablob_format(struct encrypted_key_payload *epayload,
         ascii_buf[asciiblob_len] = '\0';
 
         /* copy datablob master_desc and datalen strings */
-        len = sprintf(ascii_buf, "%s %s ", epayload->master_desc,
-                      epayload->datalen);
+        len = sprintf(ascii_buf, "%s %s %s ", epayload->format,
+                      epayload->master_desc, epayload->datalen);
 
         /* convert the hex encoded iv, encrypted-data and HMAC to ascii */
         bufp = &ascii_buf[len];
@@ -378,11 +468,13 @@ static struct key *request_master_key(struct encrypted_key_payload *epayload,
         } else
                 goto out;
 
-        if (IS_ERR(mkey))
+        if (IS_ERR(mkey)) {
                 pr_info("encrypted_key: key %s not found",
                         epayload->master_desc);
-        if (mkey)
-                dump_master_key(*master_key, *master_keylen);
+                goto out;
+        }
+
+        dump_master_key(*master_key, *master_keylen);
 out:
         return mkey;
 }
@@ -439,9 +531,9 @@ static int datablob_hmac_append(struct encrypted_key_payload *epayload,
         if (ret < 0)
                 goto out;
 
-        digest = epayload->master_desc + epayload->datablob_len;
+        digest = epayload->format + epayload->datablob_len;
         ret = calc_hmac(digest, derived_key, sizeof derived_key,
-                        epayload->master_desc, epayload->datablob_len);
+                        epayload->format, epayload->datablob_len);
         if (!ret)
                 dump_hmac(NULL, digest, HASH_SIZE);
 out:
@@ -450,26 +542,35 @@ out:
 
 /* verify HMAC before decrypting encrypted key */
 static int datablob_hmac_verify(struct encrypted_key_payload *epayload,
-                                const u8 *master_key, size_t master_keylen)
+                                const u8 *format, const u8 *master_key,
+                                size_t master_keylen)
 {
         u8 derived_key[HASH_SIZE];
         u8 digest[HASH_SIZE];
         int ret;
+        char *p;
+        unsigned short len;
 
         ret = get_derived_key(derived_key, AUTH_KEY, master_key, master_keylen);
         if (ret < 0)
                 goto out;
 
-        ret = calc_hmac(digest, derived_key, sizeof derived_key,
-                        epayload->master_desc, epayload->datablob_len);
+        len = epayload->datablob_len;
+        if (!format) {
+                p = epayload->master_desc;
+                len -= strlen(epayload->format) + 1;
+        } else
+                p = epayload->format;
+
+        ret = calc_hmac(digest, derived_key, sizeof derived_key, p, len);
         if (ret < 0)
                 goto out;
-        ret = memcmp(digest, epayload->master_desc + epayload->datablob_len,
+        ret = memcmp(digest, epayload->format + epayload->datablob_len,
                      sizeof digest);
         if (ret) {
                 ret = -EINVAL;
                 dump_hmac("datablob",
-                          epayload->master_desc + epayload->datablob_len,
+                          epayload->format + epayload->datablob_len,
                           HASH_SIZE);
                 dump_hmac("calc", digest, HASH_SIZE);
         }
@@ -514,13 +615,16 @@ out:
 
 /* Allocate memory for decrypted key and datablob. */
 static struct encrypted_key_payload *encrypted_key_alloc(struct key *key,
+                                                         const char *format,
                                                          const char *master_desc,
                                                          const char *datalen)
 {
         struct encrypted_key_payload *epayload = NULL;
         unsigned short datablob_len;
         unsigned short decrypted_datalen;
+        unsigned short payload_datalen;
         unsigned int encrypted_datalen;
+        unsigned int format_len;
         long dlen;
         int ret;
 
@@ -528,29 +632,43 @@ static struct encrypted_key_payload *encrypted_key_alloc(struct key *key,
         if (ret < 0 || dlen < MIN_DATA_SIZE || dlen > MAX_DATA_SIZE)
                 return ERR_PTR(-EINVAL);
 
+        format_len = (!format) ? strlen(key_format_default) : strlen(format);
         decrypted_datalen = dlen;
+        payload_datalen = decrypted_datalen;
+        if (format && !strcmp(format, key_format_ecryptfs)) {
+                if (dlen != ECRYPTFS_MAX_KEY_BYTES) {
+                        pr_err("encrypted_key: keylen for the ecryptfs format "
+                               "must be equal to %d bytes\n",
+                               ECRYPTFS_MAX_KEY_BYTES);
+                        return ERR_PTR(-EINVAL);
+                }
+                decrypted_datalen = ECRYPTFS_MAX_KEY_BYTES;
+                payload_datalen = sizeof(struct ecryptfs_auth_tok);
+        }
+
         encrypted_datalen = roundup(decrypted_datalen, blksize);
 
-        datablob_len = strlen(master_desc) + 1 + strlen(datalen) + 1
-            + ivsize + 1 + encrypted_datalen;
+        datablob_len = format_len + 1 + strlen(master_desc) + 1
+            + strlen(datalen) + 1 + ivsize + 1 + encrypted_datalen;
 
-        ret = key_payload_reserve(key, decrypted_datalen + datablob_len
+        ret = key_payload_reserve(key, payload_datalen + datablob_len
                                   + HASH_SIZE + 1);
         if (ret < 0)
                 return ERR_PTR(ret);
 
-        epayload = kzalloc(sizeof(*epayload) + decrypted_datalen +
+        epayload = kzalloc(sizeof(*epayload) + payload_datalen +
                            datablob_len + HASH_SIZE + 1, GFP_KERNEL);
         if (!epayload)
                 return ERR_PTR(-ENOMEM);
 
+        epayload->payload_datalen = payload_datalen;
         epayload->decrypted_datalen = decrypted_datalen;
         epayload->datablob_len = datablob_len;
         return epayload;
 }
 
 static int encrypted_key_decrypt(struct encrypted_key_payload *epayload,
-                                 const char *hex_encoded_iv)
+                                 const char *format, const char *hex_encoded_iv)
 {
         struct key *mkey;
         u8 derived_key[HASH_SIZE];
@@ -571,14 +689,14 @@ static int encrypted_key_decrypt(struct encrypted_key_payload *epayload,
         hex2bin(epayload->iv, hex_encoded_iv, ivsize);
         hex2bin(epayload->encrypted_data, hex_encoded_data, encrypted_datalen);
 
-        hmac = epayload->master_desc + epayload->datablob_len;
+        hmac = epayload->format + epayload->datablob_len;
         hex2bin(hmac, hex_encoded_data + (encrypted_datalen * 2), HASH_SIZE);
 
         mkey = request_master_key(epayload, &master_key, &master_keylen);
         if (IS_ERR(mkey))
                 return PTR_ERR(mkey);
 
-        ret = datablob_hmac_verify(epayload, master_key, master_keylen);
+        ret = datablob_hmac_verify(epayload, format, master_key, master_keylen);
         if (ret < 0) {
                 pr_err("encrypted_key: bad hmac (%d)\n", ret);
                 goto out;
@@ -598,13 +716,28 @@ out:
 }
 
 static void __ekey_init(struct encrypted_key_payload *epayload,
-                        const char *master_desc, const char *datalen)
+                        const char *format, const char *master_desc,
+                        const char *datalen)
 {
-        epayload->master_desc = epayload->decrypted_data
-            + epayload->decrypted_datalen;
+        unsigned int format_len;
+
+        format_len = (!format) ? strlen(key_format_default) : strlen(format);
+        epayload->format = epayload->payload_data + epayload->payload_datalen;
+        epayload->master_desc = epayload->format + format_len + 1;
         epayload->datalen = epayload->master_desc + strlen(master_desc) + 1;
         epayload->iv = epayload->datalen + strlen(datalen) + 1;
         epayload->encrypted_data = epayload->iv + ivsize + 1;
+        epayload->decrypted_data = epayload->payload_data;
+
+        if (!format)
+                memcpy(epayload->format, key_format_default, format_len);
+        else {
+                if (!strcmp(format, key_format_ecryptfs))
+                        epayload->decrypted_data =
+                                ecryptfs_get_auth_tok_key((struct ecryptfs_auth_tok *)epayload->payload_data);
+
+                memcpy(epayload->format, format, format_len);
+        }
 
         memcpy(epayload->master_desc, master_desc, strlen(master_desc));
         memcpy(epayload->datalen, datalen, strlen(datalen));
@@ -617,19 +750,29 @@ static void __ekey_init(struct encrypted_key_payload *epayload,
  * itself.  For an old key, decrypt the hex encoded data.
  */
 static int encrypted_init(struct encrypted_key_payload *epayload,
+                          const char *key_desc, const char *format,
                           const char *master_desc, const char *datalen,
                           const char *hex_encoded_iv)
 {
         int ret = 0;
 
-        __ekey_init(epayload, master_desc, datalen);
+        if (format && !strcmp(format, key_format_ecryptfs)) {
+                ret = valid_ecryptfs_desc(key_desc);
+                if (ret < 0)
+                        return ret;
+
+                ecryptfs_fill_auth_tok((struct ecryptfs_auth_tok *)epayload->payload_data,
+                                       key_desc);
+        }
+
+        __ekey_init(epayload, format, master_desc, datalen);
         if (!hex_encoded_iv) {
                 get_random_bytes(epayload->iv, ivsize);
 
                 get_random_bytes(epayload->decrypted_data,
                                  epayload->decrypted_datalen);
         } else
-                ret = encrypted_key_decrypt(epayload, hex_encoded_iv);
+                ret = encrypted_key_decrypt(epayload, format, hex_encoded_iv);
         return ret;
 }
 
@@ -646,6 +789,7 @@ static int encrypted_instantiate(struct key *key, const void *data,
 {
         struct encrypted_key_payload *epayload = NULL;
         char *datablob = NULL;
+        const char *format = NULL;
         char *master_desc = NULL;
         char *decrypted_datalen = NULL;
         char *hex_encoded_iv = NULL;
@@ -659,18 +803,19 @@ static int encrypted_instantiate(struct key *key, const void *data,
                 return -ENOMEM;
         datablob[datalen] = 0;
         memcpy(datablob, data, datalen);
-        ret = datablob_parse(datablob, &master_desc, &decrypted_datalen,
-                             &hex_encoded_iv);
+        ret = datablob_parse(datablob, &format, &master_desc,
+                             &decrypted_datalen, &hex_encoded_iv);
         if (ret < 0)
                 goto out;
 
-        epayload = encrypted_key_alloc(key, master_desc, decrypted_datalen);
+        epayload = encrypted_key_alloc(key, format, master_desc,
+                                       decrypted_datalen);
         if (IS_ERR(epayload)) {
                 ret = PTR_ERR(epayload);
                 goto out;
         }
-        ret = encrypted_init(epayload, master_desc, decrypted_datalen,
-                             hex_encoded_iv);
+        ret = encrypted_init(epayload, key->description, format, master_desc,
+                             decrypted_datalen, hex_encoded_iv);
         if (ret < 0) {
                 kfree(epayload);
                 goto out;
@@ -706,6 +851,7 @@ static int encrypted_update(struct key *key, const void *data, size_t datalen)
         struct encrypted_key_payload *new_epayload;
         char *buf;
         char *new_master_desc = NULL;
+        const char *format = NULL;
         int ret = 0;
 
         if (datalen <= 0 || datalen > 32767 || !data)
@@ -717,7 +863,7 @@ static int encrypted_update(struct key *key, const void *data, size_t datalen)
 
         buf[datalen] = 0;
         memcpy(buf, data, datalen);
-        ret = datablob_parse(buf, &new_master_desc, NULL, NULL);
+        ret = datablob_parse(buf, &format, &new_master_desc, NULL, NULL);
         if (ret < 0)
                 goto out;
 
@@ -725,18 +871,19 @@ static int encrypted_update(struct key *key, const void *data, size_t datalen)
         if (ret < 0)
                 goto out;
 
-        new_epayload = encrypted_key_alloc(key, new_master_desc,
-                                           epayload->datalen);
+        new_epayload = encrypted_key_alloc(key, epayload->format,
+                                           new_master_desc, epayload->datalen);
         if (IS_ERR(new_epayload)) {
                 ret = PTR_ERR(new_epayload);
                 goto out;
         }
 
-        __ekey_init(new_epayload, new_master_desc, epayload->datalen);
+        __ekey_init(new_epayload, epayload->format, new_master_desc,
+                    epayload->datalen);
 
         memcpy(new_epayload->iv, epayload->iv, ivsize);
-        memcpy(new_epayload->decrypted_data, epayload->decrypted_data,
-               epayload->decrypted_datalen);
+        memcpy(new_epayload->payload_data, epayload->payload_data,
+               epayload->payload_datalen);
 
         rcu_assign_pointer(key->payload.data, new_epayload);
         call_rcu(&epayload->rcu, encrypted_rcu_free);
diff --git a/security/keys/keyring.c b/security/keys/keyring.c
index a06ffab3856..30e242f7bd0 100644
--- a/security/keys/keyring.c
+++ b/security/keys/keyring.c
@@ -155,7 +155,6 @@ static void keyring_destroy(struct key *keyring)
         }
 
         klist = rcu_dereference_check(keyring->payload.subscriptions,
-                                      rcu_read_lock_held() ||
                                       atomic_read(&keyring->usage) == 0);
         if (klist) {
                 for (loop = klist->nkeys - 1; loop >= 0; loop--)
diff --git a/security/keys/request_key_auth.c b/security/keys/request_key_auth.c
index 6cff37529b8..60d4e3f5e4b 100644
--- a/security/keys/request_key_auth.c
+++ b/security/keys/request_key_auth.c
@@ -251,6 +251,8 @@ struct key *key_get_instantiation_authkey(key_serial_t target_id)
 
         if (IS_ERR(authkey_ref)) {
                 authkey = ERR_CAST(authkey_ref);
+                if (authkey == ERR_PTR(-EAGAIN))
+                        authkey = ERR_PTR(-ENOKEY);
                 goto error;
         }
 
diff --git a/security/keys/user_defined.c b/security/keys/user_defined.c
index 5b366d7af3c..69ff52c08e9 100644
--- a/security/keys/user_defined.c
+++ b/security/keys/user_defined.c
@@ -102,7 +102,8 @@ int user_update(struct key *key, const void *data, size_t datalen)
                 key->expiry = 0;
         }
 
-        kfree_rcu(zap, rcu);
+        if (zap)
+                kfree_rcu(zap, rcu);
 
 error:
         return ret;
diff --git a/security/security.c b/security/security.c
index 4ba6d4cc061..d9e15339092 100644
--- a/security/security.c
+++ b/security/security.c
@@ -518,14 +518,7 @@ int security_inode_permission(struct inode *inode, int mask)
 {
         if (unlikely(IS_PRIVATE(inode)))
                 return 0;
-        return security_ops->inode_permission(inode, mask, 0);
-}
-
-int security_inode_exec_permission(struct inode *inode, unsigned int flags)
-{
-        if (unlikely(IS_PRIVATE(inode)))
-                return 0;
-        return security_ops->inode_permission(inode, MAY_EXEC, flags);
+        return security_ops->inode_permission(inode, mask);
 }
 
 int security_inode_setattr(struct dentry *dentry, struct iattr *attr)
@@ -1104,6 +1097,7 @@ void security_sk_clone(const struct sock *sk, struct sock *newsk)
 {
         security_ops->sk_clone_security(sk, newsk);
 }
+EXPORT_SYMBOL(security_sk_clone);
 
 void security_sk_classify_flow(struct sock *sk, struct flowi *fl)
 {
diff --git a/security/selinux/avc.c b/security/selinux/avc.c
index d515b2128a4..dca1c22d927 100644
--- a/security/selinux/avc.c
+++ b/security/selinux/avc.c
@@ -527,7 +527,7 @@ int avc_audit(u32 ssid, u32 tsid,
          * happened a little later.
          */
         if ((a->type == LSM_AUDIT_DATA_INODE) &&
-            (flags & IPERM_FLAG_RCU))
+            (flags & MAY_NOT_BLOCK))
                 return -ECHILD;
 
         a->selinux_audit_data.tclass = tclass;
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index 20219ef5439..266a2292451 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -14,7 +14,7 @@
  *  Copyright (C) 2004-2005 Trusted Computer Solutions, Inc.
  *                          <dgoeddel@trustedcs.com>
  *  Copyright (C) 2006, 2007, 2009 Hewlett-Packard Development Company, L.P.
- *      Paul Moore <paul.moore@hp.com>
+ *      Paul Moore <paul@paul-moore.com>
  *  Copyright (C) 2007 Hitachi Software Engineering Co., Ltd.
  *                     Yuichi Nakamura <ynakam@hitachisoft.jp>
  *
@@ -57,7 +57,7 @@
 #include <net/netlabel.h>
 #include <linux/uaccess.h>
 #include <asm/ioctls.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <linux/bitops.h>
 #include <linux/interrupt.h>
 #include <linux/netdevice.h>    /* for network interface checks */
@@ -2053,7 +2053,7 @@ static int selinux_bprm_set_creds(struct linux_binprm *bprm)
                         u32 ptsid = 0;
 
                         rcu_read_lock();
-                        tracer = tracehook_tracer_task(current);
+                        tracer = ptrace_parent(current);
                         if (likely(tracer != NULL)) {
                                 sec = __task_cred(tracer)->security;
                                 ptsid = sec->sid;
@@ -2659,12 +2659,13 @@ static int selinux_inode_follow_link(struct dentry *dentry, struct nameidata *na
         return dentry_has_perm(cred, dentry, FILE__READ);
 }
 
-static int selinux_inode_permission(struct inode *inode, int mask, unsigned flags)
+static int selinux_inode_permission(struct inode *inode, int mask)
 {
         const struct cred *cred = current_cred();
         struct common_audit_data ad;
         u32 perms;
         bool from_access;
+        unsigned flags = mask & MAY_NOT_BLOCK;
 
         from_access = mask & MAY_ACCESS;
         mask &= (MAY_READ|MAY_WRITE|MAY_EXEC|MAY_APPEND);
@@ -5319,7 +5320,7 @@ static int selinux_setprocattr(struct task_struct *p,
                    Otherwise, leave SID unchanged and fail. */
                 ptsid = 0;
                 task_lock(p);
-                tracer = tracehook_tracer_task(p);
+                tracer = ptrace_parent(p);
                 if (tracer)
                         ptsid = task_sid(tracer);
                 task_unlock(p);
diff --git a/security/selinux/include/netif.h b/security/selinux/include/netif.h
index ce23edd128b..43d507242b4 100644
--- a/security/selinux/include/netif.h
+++ b/security/selinux/include/netif.h
@@ -8,7 +8,7 @@
  *
  * Copyright (C) 2003 Red Hat, Inc., James Morris <jmorris@redhat.com>
  * Copyright (C) 2007 Hewlett-Packard Development Company, L.P.
- *                    Paul Moore, <paul.moore@hp.com>
+ *                    Paul Moore <paul@paul-moore.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2,
diff --git a/security/selinux/include/netlabel.h b/security/selinux/include/netlabel.h
index cf2f628e6e2..8c59b8f150e 100644
--- a/security/selinux/include/netlabel.h
+++ b/security/selinux/include/netlabel.h
@@ -1,7 +1,7 @@
 /*
  * SELinux interface to the NetLabel subsystem
  *
- * Author : Paul Moore <paul.moore@hp.com>
+ * Author: Paul Moore <paul@paul-moore.com>
  *
  */
 
diff --git a/security/selinux/include/netnode.h b/security/selinux/include/netnode.h
index 1b94450d11d..df7a5ed6c69 100644
--- a/security/selinux/include/netnode.h
+++ b/security/selinux/include/netnode.h
@@ -6,7 +6,7 @@
  * needed to reduce the lookup overhead since most of these queries happen on
  * a per-packet basis.
  *
- * Author: Paul Moore <paul.moore@hp.com>
+ * Author: Paul Moore <paul@paul-moore.com>
  *
  */
 
diff --git a/security/selinux/include/netport.h b/security/selinux/include/netport.h
index 8991752eaf9..4d965b83d73 100644
--- a/security/selinux/include/netport.h
+++ b/security/selinux/include/netport.h
@@ -5,7 +5,7 @@
  * mapping is maintained as part of the normal policy but a fast cache is
  * needed to reduce the lookup overhead.
  *
- * Author: Paul Moore <paul.moore@hp.com>
+ * Author: Paul Moore <paul@paul-moore.com>
  *
  */
 
diff --git a/security/selinux/netif.c b/security/selinux/netif.c
index 58cc481c93d..326f22cbe40 100644
--- a/security/selinux/netif.c
+++ b/security/selinux/netif.c
@@ -8,7 +8,7 @@
  *
  * Copyright (C) 2003 Red Hat, Inc., James Morris <jmorris@redhat.com>
  * Copyright (C) 2007 Hewlett-Packard Development Company, L.P.
- *                    Paul Moore <paul.moore@hp.com>
+ *                    Paul Moore <paul@paul-moore.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2,
diff --git a/security/selinux/netlabel.c b/security/selinux/netlabel.c
index c3bf3ed07b0..da4b8b23328 100644
--- a/security/selinux/netlabel.c
+++ b/security/selinux/netlabel.c
@@ -4,7 +4,7 @@
  * This file provides the necessary glue to tie NetLabel into the SELinux
  * subsystem.
  *
- * Author: Paul Moore <paul.moore@hp.com>
+ * Author: Paul Moore <paul@paul-moore.com>
  *
  */
 
diff --git a/security/selinux/netnode.c b/security/selinux/netnode.c
index 3618251d0fd..3bf46abaa68 100644
--- a/security/selinux/netnode.c
+++ b/security/selinux/netnode.c
@@ -6,7 +6,7 @@
  * needed to reduce the lookup overhead since most of these queries happen on
  * a per-packet basis.
  *
- * Author: Paul Moore <paul.moore@hp.com>
+ * Author: Paul Moore <paul@paul-moore.com>
  *
  * This code is heavily based on the "netif" concept originally developed by
  * James Morris <jmorris@redhat.com>
@@ -69,22 +69,6 @@ static DEFINE_SPINLOCK(sel_netnode_lock);
 static struct sel_netnode_bkt sel_netnode_hash[SEL_NETNODE_HASH_SIZE];
 
 /**
- * sel_netnode_free - Frees a node entry
- * @p: the entry's RCU field
- *
- * Description:
- * This function is designed to be used as a callback to the call_rcu()
- * function so that memory allocated to a hash table node entry can be
- * released safely.
- *
- */
-static void sel_netnode_free(struct rcu_head *p)
-{
-        struct sel_netnode *node = container_of(p, struct sel_netnode, rcu);
-        kfree(node);
-}
-
-/**
  * sel_netnode_hashfn_ipv4 - IPv4 hashing function for the node table
  * @addr: IPv4 address
  *
@@ -193,7 +177,7 @@ static void sel_netnode_insert(struct sel_netnode *node)
                         rcu_dereference(sel_netnode_hash[idx].list.prev),
                         struct sel_netnode, list);
                 list_del_rcu(&tail->list);
-                call_rcu(&tail->rcu, sel_netnode_free);
+                kfree_rcu(tail, rcu);
         } else
                 sel_netnode_hash[idx].size++;
 }
@@ -306,7 +290,7 @@ static void sel_netnode_flush(void)
                 list_for_each_entry_safe(node, node_tmp,
                                          &sel_netnode_hash[idx].list, list) {
                                 list_del_rcu(&node->list);
-                                call_rcu(&node->rcu, sel_netnode_free);
+                                kfree_rcu(node, rcu);
                 }
                 sel_netnode_hash[idx].size = 0;
         }
diff --git a/security/selinux/netport.c b/security/selinux/netport.c
index cfe2d72d3fb..7b9eb1faf68 100644
--- a/security/selinux/netport.c
+++ b/security/selinux/netport.c
@@ -5,7 +5,7 @@
  * mapping is maintained as part of the normal policy but a fast cache is
  * needed to reduce the lookup overhead.
  *
- * Author: Paul Moore <paul.moore@hp.com>
+ * Author: Paul Moore <paul@paul-moore.com>
  *
  * This code is heavily based on the "netif" concept originally developed by
  * James Morris <jmorris@redhat.com>
@@ -68,22 +68,6 @@ static DEFINE_SPINLOCK(sel_netport_lock);
 static struct sel_netport_bkt sel_netport_hash[SEL_NETPORT_HASH_SIZE];
 
 /**
- * sel_netport_free - Frees a port entry
- * @p: the entry's RCU field
- *
- * Description:
- * This function is designed to be used as a callback to the call_rcu()
- * function so that memory allocated to a hash table port entry can be
- * released safely.
- *
- */
-static void sel_netport_free(struct rcu_head *p)
-{
-        struct sel_netport *port = container_of(p, struct sel_netport, rcu);
-        kfree(port);
-}
-
-/**
  * sel_netport_hashfn - Hashing function for the port table
  * @pnum: port number
  *
@@ -139,10 +123,12 @@ static void sel_netport_insert(struct sel_netport *port)
         if (sel_netport_hash[idx].size == SEL_NETPORT_HASH_BKT_LIMIT) {
                 struct sel_netport *tail;
                 tail = list_entry(
-                        rcu_dereference(sel_netport_hash[idx].list.prev),
+                        rcu_dereference_protected(
+                                sel_netport_hash[idx].list.prev,
+                                lockdep_is_held(&sel_netport_lock)),
                         struct sel_netport, list);
                 list_del_rcu(&tail->list);
-                call_rcu(&tail->rcu, sel_netport_free);
+                kfree_rcu(tail, rcu);
         } else
                 sel_netport_hash[idx].size++;
 }
@@ -241,7 +227,7 @@ static void sel_netport_flush(void)
                 list_for_each_entry_safe(port, port_tmp,
                                          &sel_netport_hash[idx].list, list) {
                         list_del_rcu(&port->list);
-                        call_rcu(&port->rcu, sel_netport_free);
+                        kfree_rcu(port, rcu);
                 }
                 sel_netport_hash[idx].size = 0;
         }
diff --git a/security/selinux/selinuxfs.c b/security/selinux/selinuxfs.c
index 35459340019..55d92cbb177 100644
--- a/security/selinux/selinuxfs.c
+++ b/security/selinux/selinuxfs.c
@@ -2,7 +2,7 @@
  *
  *      Added conditional policy language extensions
  *
- *  Updated: Hewlett-Packard <paul.moore@hp.com>
+ *  Updated: Hewlett-Packard <paul@paul-moore.com>
  *
  *      Added support for the policy capability bitmap
  *
@@ -1984,6 +1984,7 @@ __initcall(init_sel_fs);
 void exit_sel_fs(void)
 {
         kobject_put(selinuxfs_kobj);
+        kern_unmount(selinuxfs_mount);
         unregister_filesystem(&sel_fs_type);
 }
 #endif
diff --git a/security/selinux/ss/ebitmap.c b/security/selinux/ss/ebitmap.c
index d42951fcbe8..30f119b1d1e 100644
--- a/security/selinux/ss/ebitmap.c
+++ b/security/selinux/ss/ebitmap.c
@@ -4,7 +4,7 @@
  * Author : Stephen Smalley, <sds@epoch.ncsc.mil>
  */
 /*
- * Updated: Hewlett-Packard <paul.moore@hp.com>
+ * Updated: Hewlett-Packard <paul@paul-moore.com>
  *
  *      Added support to import/export the NetLabel category bitmap
  *
diff --git a/security/selinux/ss/mls.c b/security/selinux/ss/mls.c
index e96174216bc..fbf9c5816c7 100644
--- a/security/selinux/ss/mls.c
+++ b/security/selinux/ss/mls.c
@@ -11,7 +11,7 @@
  * Copyright (C) 2004-2006 Trusted Computer Solutions, Inc.
  */
 /*
- * Updated: Hewlett-Packard <paul.moore@hp.com>
+ * Updated: Hewlett-Packard <paul@paul-moore.com>
  *
  *      Added support to import/export the MLS label from NetLabel
  *
diff --git a/security/selinux/ss/mls.h b/security/selinux/ss/mls.h
index 037bf9d82d4..e4369e3e636 100644
--- a/security/selinux/ss/mls.h
+++ b/security/selinux/ss/mls.h
@@ -11,7 +11,7 @@
  * Copyright (C) 2004-2006 Trusted Computer Solutions, Inc.
  */
 /*
- * Updated: Hewlett-Packard <paul.moore@hp.com>
+ * Updated: Hewlett-Packard <paul@paul-moore.com>
  *
  *      Added support to import/export the MLS label from NetLabel
  *
diff --git a/security/selinux/ss/policydb.c b/security/selinux/ss/policydb.c
index d246aca3f4f..2381d0ded22 100644
--- a/security/selinux/ss/policydb.c
+++ b/security/selinux/ss/policydb.c
@@ -13,7 +13,7 @@
  *
  *      Added conditional policy language extensions
  *
- * Updated: Hewlett-Packard <paul.moore@hp.com>
+ * Updated: Hewlett-Packard <paul@paul-moore.com>
  *
  *      Added support for the policy capability bitmap
  *
diff --git a/security/selinux/ss/services.c b/security/selinux/ss/services.c
index 973e00e34fa..f6917bc0aa0 100644
--- a/security/selinux/ss/services.c
+++ b/security/selinux/ss/services.c
@@ -13,7 +13,7 @@
  *
  *      Added conditional policy language extensions
  *
- * Updated: Hewlett-Packard <paul.moore@hp.com>
+ * Updated: Hewlett-Packard <paul@paul-moore.com>
  *
  *      Added support for NetLabel
  *      Added support for the policy capability bitmap
diff --git a/security/selinux/xfrm.c b/security/selinux/xfrm.c
index 68178b76a2b..48665ecd119 100644
--- a/security/selinux/xfrm.c
+++ b/security/selinux/xfrm.c
@@ -46,7 +46,7 @@
 #include <net/xfrm.h>
 #include <net/checksum.h>
 #include <net/udp.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 
 #include "avc.h"
 #include "objsec.h"
diff --git a/security/smack/smack_lsm.c b/security/smack/smack_lsm.c
index 9831a39c11f..b9c5e149903 100644
--- a/security/smack/smack_lsm.c
+++ b/security/smack/smack_lsm.c
@@ -9,7 +9,7 @@
  *
  *  Copyright (C) 2007 Casey Schaufler <casey@schaufler-ca.com>
  *  Copyright (C) 2009 Hewlett-Packard Development Company, L.P.
- *                Paul Moore <paul.moore@hp.com>
+ *                Paul Moore <paul@paul-moore.com>
  *  Copyright (C) 2010 Nokia Corporation
  *
  *      This program is free software; you can redistribute it and/or modify
@@ -689,9 +689,10 @@ static int smack_inode_rename(struct inode *old_inode,
  *
  * Returns 0 if access is permitted, -EACCES otherwise
  */
-static int smack_inode_permission(struct inode *inode, int mask, unsigned flags)
+static int smack_inode_permission(struct inode *inode, int mask)
 {
         struct smk_audit_info ad;
+        int no_block = mask & MAY_NOT_BLOCK;
 
         mask &= (MAY_READ|MAY_WRITE|MAY_EXEC|MAY_APPEND);
         /*
@@ -701,7 +702,7 @@ static int smack_inode_permission(struct inode *inode, int mask, unsigned flags)
                 return 0;
 
         /* May be droppable after audit */
-        if (flags & IPERM_FLAG_RCU)
+        if (no_block)
                 return -ECHILD;
         smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_INODE);
         smk_ad_setfield_u_fs_inode(&ad, inode);
diff --git a/security/tf_driver/Kconfig b/security/tf_driver/Kconfig
new file mode 100644
index 00000000000..2a980c5ade4
--- /dev/null
+++ b/security/tf_driver/Kconfig
@@ -0,0 +1,8 @@
+config TRUSTED_FOUNDATIONS
+        bool "Enable TF Driver"
+        default n
+        select CRYPTO_SHA1
+        help
+          This option adds kernel support for communication with the Trusted Foundations.
+          If you are unsure how to answer this question, answer N.
+
diff --git a/security/tf_driver/Makefile b/security/tf_driver/Makefile
new file mode 100644
index 00000000000..dfadb7d9740
--- /dev/null
+++ b/security/tf_driver/Makefile
@@ -0,0 +1,36 @@
+#
+# Copyright (c) 2006-2010 Trusted Logic S.A.
+# All Rights Reserved.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as
+# published by the Free Software Foundation; either version 2 of
+# the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+# MA 02111-1307 USA
+#
+
+# debug options
+#EXTRA_CFLAGS += -O0 -DDEBUG -D_DEBUG -DCONFIG_TF_DRIVER_DEBUG_SUPPORT
+EXTRA_CFLAGS += -DNDEBUG
+EXTRA_CFLAGS += -DLINUX -DCONFIG_TF_TRUSTZONE -DCONFIG_TFN
+
+ifdef S_VERSION_BUILD
+EXTRA_CFLAGS += -DS_VERSION_BUILD=$(S_VERSION_BUILD)
+endif
+
+tf_driver-objs += tf_util.o
+tf_driver-objs += tf_conn.o
+tf_driver-objs += tf_device.o
+tf_driver-objs += tf_comm.o
+tf_driver-objs += tf_comm_tz.o
+
+obj-$(CONFIG_TRUSTED_FOUNDATIONS) += tf_driver.o
diff --git a/security/tf_driver/s_version.h b/security/tf_driver/s_version.h
new file mode 100644
index 00000000000..6244d3fe7e8
--- /dev/null
+++ b/security/tf_driver/s_version.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2011 Trusted Logic S.A.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#ifndef __S_VERSION_H__
+#define __S_VERSION_H__
+
+/*
+ * Usage: define S_VERSION_BUILD on the compiler's command line.
+ *
+ * Then set:
+ * - S_VERSION_OS
+ * - S_VERSION_PLATFORM
+ * - S_VERSION_MAIN
+ * - S_VERSION_ENG is optional
+ * - S_VERSION_PATCH is optional
+ * - S_VERSION_BUILD = 0 if S_VERSION_BUILD not defined or empty
+ */
+
+#define S_VERSION_OS "A"          /* "A" for all Android */
+#define S_VERSION_PLATFORM "B"    /* "B" for Tegra3 */
+
+/*
+ * This version number must be updated for each new release
+ */
+#define S_VERSION_MAIN  "01.03"
+
+/*
+* If this is a patch or engineering version use the following
+* defines to set the version number. Else set these values to 0.
+*/
+#define S_VERSION_ENG 0
+#define S_VERSION_PATCH 0
+
+#ifdef S_VERSION_BUILD
+/* TRICK: detect if S_VERSION is defined but empty */
+#if 0 == S_VERSION_BUILD-0
+#undef  S_VERSION_BUILD
+#define S_VERSION_BUILD 0
+#endif
+#else
+/* S_VERSION_BUILD is not defined */
+#define S_VERSION_BUILD 0
+#endif
+
+#define __STRINGIFY(X) #X
+#define __STRINGIFY2(X) __STRINGIFY(X)
+
+#if S_VERSION_ENG != 0
+#define _S_VERSION_ENG "e" __STRINGIFY2(S_VERSION_ENG)
+#else
+#define _S_VERSION_ENG ""
+#endif
+
+#if S_VERSION_PATCH != 0
+#define _S_VERSION_PATCH "p" __STRINGIFY2(S_VERSION_PATCH)
+#else
+#define _S_VERSION_PATCH ""
+#endif
+
+#if !defined(NDEBUG) || defined(_DEBUG)
+#define S_VERSION_VARIANT "D   "
+#else
+#define S_VERSION_VARIANT "    "
+#endif
+
+#define S_VERSION_STRING \
+        "TFN" \
+        S_VERSION_OS \
+        S_VERSION_PLATFORM \
+        S_VERSION_MAIN \
+        _S_VERSION_ENG \
+        _S_VERSION_PATCH \
+        "."  __STRINGIFY2(S_VERSION_BUILD) " " \
+        S_VERSION_VARIANT
+
+#endif /* __S_VERSION_H__ */
diff --git a/security/tf_driver/tf_comm.c b/security/tf_driver/tf_comm.c
new file mode 100644
index 00000000000..16915beb406
--- /dev/null
+++ b/security/tf_driver/tf_comm.c
@@ -0,0 +1,1745 @@
+/**
+ * Copyright (c) 2011 Trusted Logic S.A.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#include <asm/div64.h>
+#include <asm/system.h>
+#include <linux/version.h>
+#include <asm/cputype.h>
+#include <linux/interrupt.h>
+#include <linux/page-flags.h>
+#include <linux/pagemap.h>
+#include <linux/vmalloc.h>
+#include <linux/jiffies.h>
+#include <linux/freezer.h>
+
+#include "tf_defs.h"
+#include "tf_comm.h"
+#include "tf_protocol.h"
+#include "tf_util.h"
+#include "tf_conn.h"
+
+#ifdef CONFIG_TF_ZEBRA
+#include "tf_zebra.h"
+#endif
+
+/*---------------------------------------------------------------------------
+ * Internal Constants
+ *---------------------------------------------------------------------------*/
+
+/*
+ * shared memories descriptor constants
+ */
+#define DESCRIPTOR_B_MASK           (1 << 2)
+#define DESCRIPTOR_C_MASK           (1 << 3)
+#define DESCRIPTOR_S_MASK           (1 << 10)
+
+#define L1_COARSE_DESCRIPTOR_BASE         (0x00000001)
+#define L1_COARSE_DESCRIPTOR_ADDR_MASK    (0xFFFFFC00)
+#define L1_COARSE_DESCRIPTOR_V13_12_SHIFT (5)
+
+#define L2_PAGE_DESCRIPTOR_BASE              (0x00000003)
+#define L2_PAGE_DESCRIPTOR_AP_APX_READ       (0x220)
+#define L2_PAGE_DESCRIPTOR_AP_APX_READ_WRITE (0x30)
+
+#define L2_INIT_DESCRIPTOR_BASE           (0x00000003)
+#define L2_INIT_DESCRIPTOR_V13_12_SHIFT   (4)
+
+/*
+ * Reject an attempt to share a strongly-Ordered or Device memory
+ * Strongly-Ordered:  TEX=0b000, C=0, B=0
+ * Shared Device:     TEX=0b000, C=0, B=1
+ * Non-Shared Device: TEX=0b010, C=0, B=0
+ */
+#define L2_TEX_C_B_MASK \
+        ((1<<8) | (1<<7) | (1<<6) | (1<<3) | (1<<2))
+#define L2_TEX_C_B_STRONGLY_ORDERED \
+        ((0<<8) | (0<<7) | (0<<6) | (0<<3) | (0<<2))
+#define L2_TEX_C_B_SHARED_DEVICE \
+        ((0<<8) | (0<<7) | (0<<6) | (0<<3) | (1<<2))
+#define L2_TEX_C_B_NON_SHARED_DEVICE \
+        ((0<<8) | (1<<7) | (0<<6) | (0<<3) | (0<<2))
+
+#define CACHE_S(x)      ((x) & (1 << 24))
+#define CACHE_DSIZE(x)  (((x) >> 12) & 4095)
+
+#define TIME_IMMEDIATE ((u64) 0x0000000000000000ULL)
+#define TIME_INFINITE  ((u64) 0xFFFFFFFFFFFFFFFFULL)
+
+/*---------------------------------------------------------------------------
+ * atomic operation definitions
+ *---------------------------------------------------------------------------*/
+
+/*
+ * Atomically updates the sync_serial_n and time_n register
+ * sync_serial_n and time_n modifications are thread safe
+ */
+void tf_set_current_time(struct tf_comm *comm)
+{
+        u32 new_sync_serial;
+        struct timeval now;
+        u64 time64;
+
+        /*
+         * lock the structure while updating the L1 shared memory fields
+         */
+        spin_lock(&comm->lock);
+
+        /* read sync_serial_n and change the TimeSlot bit field */
+        new_sync_serial =
+                tf_read_reg32(&comm->l1_buffer->sync_serial_n) + 1;
+
+        do_gettimeofday(&now);
+        time64 = now.tv_sec;
+        time64 = (time64 * 1000) + (now.tv_usec / 1000);
+
+        /* Write the new time64 and nSyncSerial into shared memory */
+        tf_write_reg64(&comm->l1_buffer->time_n[new_sync_serial &
+                TF_SYNC_SERIAL_TIMESLOT_N], time64);
+        tf_write_reg32(&comm->l1_buffer->sync_serial_n,
+                new_sync_serial);
+
+        spin_unlock(&comm->lock);
+}
+
+/*
+ * Performs the specific read timeout operation
+ * The difficulty here is to read atomically 2 u32
+ * values from the L1 shared buffer.
+ * This is guaranteed by reading before and after the operation
+ * the timeslot given by the Secure World
+ */
+static inline void tf_read_timeout(struct tf_comm *comm, u64 *time)
+{
+        u32 sync_serial_s_initial = 0;
+        u32 sync_serial_s_final = 1;
+        u64 time64;
+
+        spin_lock(&comm->lock);
+
+        while (sync_serial_s_initial != sync_serial_s_final) {
+                sync_serial_s_initial = tf_read_reg32(
+                        &comm->l1_buffer->sync_serial_s);
+                time64 = tf_read_reg64(
+                        &comm->l1_buffer->timeout_s[sync_serial_s_initial&1]);
+
+                sync_serial_s_final = tf_read_reg32(
+                        &comm->l1_buffer->sync_serial_s);
+        }
+
+        spin_unlock(&comm->lock);
+
+        *time = time64;
+}
+
+/*----------------------------------------------------------------------------
+ * SIGKILL signal handling
+ *----------------------------------------------------------------------------*/
+
+static bool sigkill_pending(void)
+{
+        if (signal_pending(current)) {
+                dprintk(KERN_INFO "A signal is pending\n");
+                if (sigismember(&current->pending.signal, SIGKILL)) {
+                        dprintk(KERN_INFO "A SIGKILL is pending\n");
+                        return true;
+                } else if (sigismember(
+                        &current->signal->shared_pending.signal, SIGKILL)) {
+                        dprintk(KERN_INFO "A SIGKILL is pending (shared)\n");
+                        return true;
+                }
+        }
+        return false;
+}
+
+/*----------------------------------------------------------------------------
+ * Shared memory related operations
+ *----------------------------------------------------------------------------*/
+
+struct tf_coarse_page_table *tf_alloc_coarse_page_table(
+        struct tf_coarse_page_table_allocation_context *alloc_context,
+        u32 type)
+{
+        struct tf_coarse_page_table *coarse_pg_table = NULL;
+
+        spin_lock(&(alloc_context->lock));
+
+        if (!(list_empty(&(alloc_context->free_coarse_page_tables)))) {
+                /*
+                 * The free list can provide us a coarse page table
+                 * descriptor
+                 */
+                coarse_pg_table = list_first_entry(
+                                &alloc_context->free_coarse_page_tables,
+                                struct tf_coarse_page_table, list);
+                list_del(&(coarse_pg_table->list));
+
+                coarse_pg_table->parent->ref_count++;
+        } else {
+                /* no array of coarse page tables, create a new one */
+                struct tf_coarse_page_table_array *array;
+                void *page;
+                int i;
+
+                spin_unlock(&(alloc_context->lock));
+
+                /* first allocate a new page descriptor */
+                array = internal_kmalloc(sizeof(*array), GFP_KERNEL);
+                if (array == NULL) {
+                        dprintk(KERN_ERR "tf_alloc_coarse_page_table(%p):"
+                                        " failed to allocate a table array\n",
+                                        alloc_context);
+                        return NULL;
+                }
+
+                array->type = type;
+                INIT_LIST_HEAD(&(array->list));
+
+                /* now allocate the actual page the page descriptor describes */
+                page = (void *) internal_get_zeroed_page(GFP_KERNEL);
+                if (page == NULL) {
+                        dprintk(KERN_ERR "tf_alloc_coarse_page_table(%p):"
+                                        " failed allocate a page\n",
+                                        alloc_context);
+                        internal_kfree(array);
+                        return NULL;
+                }
+
+                spin_lock(&(alloc_context->lock));
+
+                /* initialize the coarse page table descriptors */
+                for (i = 0; i < 4; i++) {
+                        INIT_LIST_HEAD(&(array->coarse_page_tables[i].list));
+                        array->coarse_page_tables[i].descriptors =
+                                page + (i * SIZE_1KB);
+                        array->coarse_page_tables[i].parent = array;
+
+                        if (i == 0) {
+                                /*
+                                 * the first element is kept for the current
+                                 * coarse page table allocation
+                                 */
+                                coarse_pg_table =
+                                        &(array->coarse_page_tables[i]);
+                                array->ref_count = 1;
+                        } else {
+                                /*
+                                 * The other elements are added to the free list
+                                 */
+                                list_add(&(array->coarse_page_tables[i].list),
+                                        &(alloc_context->
+                                                free_coarse_page_tables));
+                        }
+                }
+
+                list_add(&(array->list),
+                        &(alloc_context->coarse_page_table_arrays));
+        }
+        spin_unlock(&(alloc_context->lock));
+
+        return coarse_pg_table;
+}
+
+
+void tf_free_coarse_page_table(
+        struct tf_coarse_page_table_allocation_context *alloc_context,
+        struct tf_coarse_page_table *coarse_pg_table,
+        int force)
+{
+        struct tf_coarse_page_table_array *array;
+
+        spin_lock(&(alloc_context->lock));
+
+        array = coarse_pg_table->parent;
+
+        (array->ref_count)--;
+
+        if (array->ref_count == 0) {
+                /*
+                 * no coarse page table descriptor is used
+                 * check if we should free the whole page
+                 */
+
+                if ((array->type == TF_PAGE_DESCRIPTOR_TYPE_PREALLOCATED)
+                        && (force == 0))
+                        /*
+                         * This is a preallocated page,
+                         * add the page back to the free list
+                         */
+                        list_add(&(coarse_pg_table->list),
+                                &(alloc_context->free_coarse_page_tables));
+                else {
+                        /*
+                         * None of the page's coarse page table descriptors
+                         * are in use, free the whole page
+                         */
+                        int i;
+                        u32 *descriptors;
+
+                        /*
+                         * remove the page's associated coarse page table
+                         * descriptors from the free list
+                         */
+                        for (i = 0; i < 4; i++)
+                                if (&(array->coarse_page_tables[i]) !=
+                                                coarse_pg_table)
+                                        list_del(&(array->
+                                                coarse_page_tables[i].list));
+
+                        descriptors =
+                                array->coarse_page_tables[0].descriptors;
+                        array->coarse_page_tables[0].descriptors = NULL;
+
+                        /* remove the coarse page table from the array  */
+                        list_del(&(array->list));
+
+                        spin_unlock(&(alloc_context->lock));
+                        /*
+                         * Free the page.
+                         * The address of the page is contained in the first
+                         * element
+                         */
+                        internal_free_page((unsigned long) descriptors);
+                        /* finaly free the array */
+                        internal_kfree(array);
+
+                        spin_lock(&(alloc_context->lock));
+                }
+        } else {
+                /*
+                 * Some coarse page table descriptors are in use.
+                 * Add the descriptor to the free list
+                 */
+                list_add(&(coarse_pg_table->list),
+                        &(alloc_context->free_coarse_page_tables));
+        }
+
+        spin_unlock(&(alloc_context->lock));
+}
+
+
+void tf_init_coarse_page_table_allocator(
+        struct tf_coarse_page_table_allocation_context *alloc_context)
+{
+        spin_lock_init(&(alloc_context->lock));
+        INIT_LIST_HEAD(&(alloc_context->coarse_page_table_arrays));
+        INIT_LIST_HEAD(&(alloc_context->free_coarse_page_tables));
+}
+
+void tf_release_coarse_page_table_allocator(
+        struct tf_coarse_page_table_allocation_context *alloc_context)
+{
+        spin_lock(&(alloc_context->lock));
+
+        /* now clean up the list of page descriptors */
+        while (!list_empty(&(alloc_context->coarse_page_table_arrays))) {
+                struct tf_coarse_page_table_array *page_desc;
+                u32 *descriptors;
+
+                page_desc = list_first_entry(
+                        &alloc_context->coarse_page_table_arrays,
+                        struct tf_coarse_page_table_array, list);
+
+                descriptors = page_desc->coarse_page_tables[0].descriptors;
+                list_del(&(page_desc->list));
+
+                spin_unlock(&(alloc_context->lock));
+
+                if (descriptors != NULL)
+                        internal_free_page((unsigned long)descriptors);
+
+                internal_kfree(page_desc);
+
+                spin_lock(&(alloc_context->lock));
+        }
+
+        spin_unlock(&(alloc_context->lock));
+}
+
+/*
+ * Returns the L1 coarse page descriptor for
+ * a coarse page table located at address coarse_pg_table_descriptors
+ */
+u32 tf_get_l1_coarse_descriptor(
+        u32 coarse_pg_table_descriptors[256])
+{
+        u32 descriptor = L1_COARSE_DESCRIPTOR_BASE;
+        unsigned int info = read_cpuid(CPUID_CACHETYPE);
+
+        descriptor |= (virt_to_phys((void *) coarse_pg_table_descriptors)
+                & L1_COARSE_DESCRIPTOR_ADDR_MASK);
+
+        if (CACHE_S(info) && (CACHE_DSIZE(info) & (1 << 11))) {
+                dprintk(KERN_DEBUG "tf_get_l1_coarse_descriptor "
+                        "V31-12 added to descriptor\n");
+                /* the 16k alignment restriction applies */
+                descriptor |= (DESCRIPTOR_V13_12_GET(
+                        (u32)coarse_pg_table_descriptors) <<
+                                L1_COARSE_DESCRIPTOR_V13_12_SHIFT);
+        }
+
+        return descriptor;
+}
+
+
+#define dprintk_desc(...)
+/*
+ * Returns the L2 descriptor for the specified user page.
+ */
+u32 tf_get_l2_descriptor_common(u32 vaddr, struct mm_struct *mm)
+{
+        pgd_t *pgd;
+        pud_t *pud;
+        pmd_t *pmd;
+        pte_t *ptep;
+        u32  *hwpte;
+        u32   tex = 0;
+        u32 descriptor = 0;
+
+        dprintk_desc(KERN_INFO "VirtAddr = %x\n", vaddr);
+        pgd = pgd_offset(mm, vaddr);
+        dprintk_desc(KERN_INFO "pgd = %x, value=%x\n", (unsigned int) pgd,
+                (unsigned int) *pgd);
+        if (pgd_none(*pgd))
+                goto error;
+        pud = pud_offset(pgd, vaddr);
+        dprintk_desc(KERN_INFO "pud = %x, value=%x\n", (unsigned int) pud,
+                (unsigned int) *pud);
+        if (pud_none(*pud))
+                goto error;
+        pmd = pmd_offset(pud, vaddr);
+        dprintk_desc(KERN_INFO "pmd = %x, value=%x\n", (unsigned int) pmd,
+                (unsigned int) *pmd);
+        if (pmd_none(*pmd))
+                goto error;
+
+        if (PMD_TYPE_SECT&(*pmd)) {
+                /* We have a section */
+                dprintk_desc(KERN_INFO "Section descr=%x\n",
+                        (unsigned int)*pmd);
+                if ((*pmd) & PMD_SECT_BUFFERABLE)
+                        descriptor |= DESCRIPTOR_B_MASK;
+                if ((*pmd) & PMD_SECT_CACHEABLE)
+                        descriptor |= DESCRIPTOR_C_MASK;
+                if ((*pmd) & PMD_SECT_S)
+                        descriptor |= DESCRIPTOR_S_MASK;
+                tex = ((*pmd) >> 12) & 7;
+        } else {
+                /* We have a table */
+                ptep = pte_offset_map(pmd, vaddr);
+                if (pte_present(*ptep)) {
+                        dprintk_desc(KERN_INFO "L2 descr=%x\n",
+                                (unsigned int) *ptep);
+                        if ((*ptep) & L_PTE_MT_BUFFERABLE)
+                                descriptor |= DESCRIPTOR_B_MASK;
+                        if ((*ptep) & L_PTE_MT_WRITETHROUGH)
+                                descriptor |= DESCRIPTOR_C_MASK;
+                        if ((*ptep) & L_PTE_MT_DEV_SHARED)
+                                descriptor |= DESCRIPTOR_S_MASK;
+
+                        /*
+                         * Linux's pte doesn't keep track of TEX value.
+                         * Have to jump to hwpte see include/asm/pgtable.h
+                         * (-2k before 2.6.38, then +2k)
+                         */
+#ifdef PTE_HWTABLE_SIZE
+                        hwpte = (u32 *) (ptep+PTE_HWTABLE_PTRS);
+#else
+                        hwpte = (u32 *) (ptep-PTRS_PER_PTE);
+#endif
+                        if (((*hwpte) & L2_DESCRIPTOR_ADDR_MASK) !=
+                                        ((*ptep) & L2_DESCRIPTOR_ADDR_MASK))
+                                goto error;
+                        dprintk_desc(KERN_INFO "hw descr=%x\n", *hwpte);
+                        tex = ((*hwpte) >> 6) & 7;
+                        pte_unmap(ptep);
+                } else {
+                        pte_unmap(ptep);
+                        goto error;
+                }
+        }
+
+        descriptor |= (tex << 6);
+
+        return descriptor;
+
+error:
+        dprintk(KERN_ERR "Error occured in %s\n", __func__);
+        return 0;
+}
+
+
+/*
+ * Changes an L2 page descriptor back to a pointer to a physical page
+ */
+inline struct page *tf_l2_page_descriptor_to_page(u32 l2_page_descriptor)
+{
+        return pte_page(l2_page_descriptor & L2_DESCRIPTOR_ADDR_MASK);
+}
+
+
+/*
+ * Returns the L1 descriptor for the 1KB-aligned coarse page table. The address
+ * must be in the kernel address space.
+ */
+static void tf_get_l2_page_descriptor(
+        u32 *l2_page_descriptor,
+        u32 flags, struct mm_struct *mm)
+{
+        unsigned long page_vaddr;
+        u32 descriptor;
+        struct page *page;
+        bool unmap_page = false;
+
+#if 0
+        dprintk(KERN_INFO
+                "tf_get_l2_page_descriptor():"
+                "*l2_page_descriptor=%x\n",
+                *l2_page_descriptor);
+#endif
+
+        if (*l2_page_descriptor == L2_DESCRIPTOR_FAULT)
+                return;
+
+        page = (struct page *) (*l2_page_descriptor);
+
+        page_vaddr = (unsigned long) page_address(page);
+        if (page_vaddr == 0) {
+                dprintk(KERN_INFO "page_address returned 0\n");
+                /* Should we use kmap_atomic(page, KM_USER0) instead ? */
+                page_vaddr = (unsigned long) kmap(page);
+                if (page_vaddr == 0) {
+                        *l2_page_descriptor = L2_DESCRIPTOR_FAULT;
+                        dprintk(KERN_ERR "kmap returned 0\n");
+                        return;
+                }
+                unmap_page = true;
+        }
+
+        descriptor = tf_get_l2_descriptor_common(page_vaddr, mm);
+        if (descriptor == 0) {
+                *l2_page_descriptor = L2_DESCRIPTOR_FAULT;
+                return;
+        }
+        descriptor |= L2_PAGE_DESCRIPTOR_BASE;
+
+        descriptor |= (page_to_phys(page) & L2_DESCRIPTOR_ADDR_MASK);
+
+        if (!(flags & TF_SHMEM_TYPE_WRITE))
+                /* only read access */
+                descriptor |= L2_PAGE_DESCRIPTOR_AP_APX_READ;
+        else
+                /* read and write access */
+                descriptor |= L2_PAGE_DESCRIPTOR_AP_APX_READ_WRITE;
+
+        if (unmap_page)
+                kunmap(page);
+
+        *l2_page_descriptor = descriptor;
+}
+
+
+/*
+ * Unlocks the physical memory pages
+ * and frees the coarse pages that need to
+ */
+void tf_cleanup_shared_memory(
+        struct tf_coarse_page_table_allocation_context *alloc_context,
+        struct tf_shmem_desc *shmem_desc,
+        u32 full_cleanup)
+{
+        u32 coarse_page_index;
+
+        dprintk(KERN_INFO "tf_cleanup_shared_memory(%p)\n",
+                        shmem_desc);
+
+#ifdef DEBUG_COARSE_TABLES
+        printk(KERN_DEBUG "tf_cleanup_shared_memory "
+                "- number of coarse page tables=%d\n",
+                shmem_desc->coarse_pg_table_count);
+
+        for (coarse_page_index = 0;
+             coarse_page_index < shmem_desc->coarse_pg_table_count;
+             coarse_page_index++) {
+                u32 j;
+
+                printk(KERN_DEBUG "  Descriptor=%p address=%p index=%d\n",
+                        shmem_desc->coarse_pg_table[coarse_page_index],
+                        shmem_desc->coarse_pg_table[coarse_page_index]->
+                                descriptors,
+                        coarse_page_index);
+                if (shmem_desc->coarse_pg_table[coarse_page_index] != NULL) {
+                        for (j = 0;
+                             j < TF_DESCRIPTOR_TABLE_CAPACITY;
+                             j += 8) {
+                                int k;
+                                printk(KERN_DEBUG "    ");
+                                for (k = j; k < j + 8; k++)
+                                        printk(KERN_DEBUG "%p ",
+                                                shmem_desc->coarse_pg_table[
+                                                        coarse_page_index]->
+                                                                descriptors);
+                                printk(KERN_DEBUG "\n");
+                        }
+                }
+        }
+        printk(KERN_DEBUG "tf_cleanup_shared_memory() - done\n\n");
+#endif
+
+        /* Parse the coarse page descriptors */
+        for (coarse_page_index = 0;
+             coarse_page_index < shmem_desc->coarse_pg_table_count;
+             coarse_page_index++) {
+                u32 j;
+                u32 found = 0;
+
+                /* parse the page descriptors of the coarse page */
+                for (j = 0; j < TF_DESCRIPTOR_TABLE_CAPACITY; j++) {
+                        u32 l2_page_descriptor = (u32) (shmem_desc->
+                                coarse_pg_table[coarse_page_index]->
+                                        descriptors[j]);
+
+                        if (l2_page_descriptor != L2_DESCRIPTOR_FAULT) {
+                                struct page *page =
+                                        tf_l2_page_descriptor_to_page(
+                                                l2_page_descriptor);
+
+                                if (!PageReserved(page))
+                                        SetPageDirty(page);
+                                internal_page_cache_release(page);
+
+                                found = 1;
+                        } else if (found == 1) {
+                                break;
+                        }
+                }
+
+                /*
+                 * Only free the coarse pages of descriptors not preallocated
+                 */
+                if ((shmem_desc->type == TF_SHMEM_TYPE_REGISTERED_SHMEM) ||
+                        (full_cleanup != 0))
+                        tf_free_coarse_page_table(alloc_context,
+                                shmem_desc->coarse_pg_table[coarse_page_index],
+                                0);
+        }
+
+        shmem_desc->coarse_pg_table_count = 0;
+        dprintk(KERN_INFO "tf_cleanup_shared_memory(%p) done\n",
+                        shmem_desc);
+}
+
+/*
+ * Make sure the coarse pages are allocated. If not allocated, do it.
+ * Locks down the physical memory pages.
+ * Verifies the memory attributes depending on flags.
+ */
+int tf_fill_descriptor_table(
+        struct tf_coarse_page_table_allocation_context *alloc_context,
+        struct tf_shmem_desc *shmem_desc,
+        u32 buffer,
+        struct vm_area_struct **vmas,
+        u32 descriptors[TF_MAX_COARSE_PAGES],
+        u32 buffer_size,
+        u32 *buffer_start_offset,
+        bool in_user_space,
+        u32 flags,
+        u32 *descriptor_count)
+{
+        u32 coarse_page_index;
+        u32 coarse_page_count;
+        u32 page_count;
+        u32 page_shift = 0;
+        int ret = 0;
+        unsigned int info = read_cpuid(CPUID_CACHETYPE);
+
+        dprintk(KERN_INFO "tf_fill_descriptor_table"
+                "(%p, buffer=0x%08X, size=0x%08X, user=%01x "
+                "flags = 0x%08x)\n",
+                shmem_desc,
+                buffer,
+                buffer_size,
+                in_user_space,
+                flags);
+
+        /*
+         * Compute the number of pages
+         * Compute the number of coarse pages
+         * Compute the page offset
+         */
+        page_count = ((buffer & ~PAGE_MASK) +
+                buffer_size + ~PAGE_MASK) >> PAGE_SHIFT;
+
+        /* check whether the 16k alignment restriction applies */
+        if (CACHE_S(info) && (CACHE_DSIZE(info) & (1 << 11)))
+                /*
+                 * The 16k alignment restriction applies.
+                 * Shift data to get them 16k aligned
+                 */
+                page_shift = DESCRIPTOR_V13_12_GET(buffer);
+        page_count += page_shift;
+
+
+        /*
+         * Check the number of pages fit in the coarse pages
+         */
+        if (page_count > (TF_DESCRIPTOR_TABLE_CAPACITY *
+                        TF_MAX_COARSE_PAGES)) {
+                dprintk(KERN_ERR "tf_fill_descriptor_table(%p): "
+                        "%u pages required to map shared memory!\n",
+                        shmem_desc, page_count);
+                ret = -ENOMEM;
+                goto error;
+        }
+
+        /* coarse page describe 256 pages */
+        coarse_page_count = ((page_count +
+                TF_DESCRIPTOR_TABLE_CAPACITY_MASK) >>
+                        TF_DESCRIPTOR_TABLE_CAPACITY_BIT_SHIFT);
+
+        /*
+         * Compute the buffer offset
+         */
+        *buffer_start_offset = (buffer & ~PAGE_MASK) |
+                (page_shift << PAGE_SHIFT);
+
+        /* map each coarse page */
+        for (coarse_page_index = 0;
+             coarse_page_index < coarse_page_count;
+             coarse_page_index++) {
+                u32 j;
+                struct tf_coarse_page_table *coarse_pg_table;
+
+                /* compute a virtual address with appropriate offset */
+                u32 buffer_offset_vaddr = buffer +
+                        (coarse_page_index * TF_MAX_COARSE_PAGE_MAPPED_SIZE);
+                u32 pages_to_get;
+
+                /*
+                 * Compute the number of pages left for this coarse page.
+                 * Decrement page_count each time
+                 */
+                pages_to_get = (page_count >>
+                        TF_DESCRIPTOR_TABLE_CAPACITY_BIT_SHIFT) ?
+                                TF_DESCRIPTOR_TABLE_CAPACITY : page_count;
+                page_count -= pages_to_get;
+
+                /*
+                 * Check if the coarse page has already been allocated
+                 * If not, do it now
+                 */
+                if ((shmem_desc->type == TF_SHMEM_TYPE_REGISTERED_SHMEM)
+                        || (shmem_desc->type ==
+                                TF_SHMEM_TYPE_PM_HIBERNATE)) {
+                        coarse_pg_table = tf_alloc_coarse_page_table(
+                                alloc_context,
+                                TF_PAGE_DESCRIPTOR_TYPE_NORMAL);
+
+                        if (coarse_pg_table == NULL) {
+                                dprintk(KERN_ERR
+                                        "tf_fill_descriptor_table(%p): "
+                                        "tf_alloc_coarse_page_table "
+                                        "failed for coarse page %d\n",
+                                        shmem_desc, coarse_page_index);
+                                ret = -ENOMEM;
+                                goto error;
+                        }
+
+                        shmem_desc->coarse_pg_table[coarse_page_index] =
+                                coarse_pg_table;
+                } else {
+                        coarse_pg_table =
+                                shmem_desc->coarse_pg_table[coarse_page_index];
+                }
+
+                /*
+                 * The page is not necessarily filled with zeroes.
+                 * Set the fault descriptors ( each descriptor is 4 bytes long)
+                 */
+                memset(coarse_pg_table->descriptors, 0x00,
+                        TF_DESCRIPTOR_TABLE_CAPACITY * sizeof(u32));
+
+                if (in_user_space) {
+                        int pages;
+
+                        /*
+                         * TRICK: use pCoarsePageDescriptor->descriptors to
+                         * hold the (struct page*) items before getting their
+                         * physical address
+                         */
+                        down_read(&(current->mm->mmap_sem));
+                        pages = internal_get_user_pages(
+                                current,
+                                current->mm,
+                                buffer_offset_vaddr,
+                                /*
+                                 * page_shift is cleared after retrieving first
+                                 * coarse page
+                                 */
+                                (pages_to_get - page_shift),
+                                (flags & TF_SHMEM_TYPE_WRITE) ? 1 : 0,
+                                0,
+                                (struct page **) (coarse_pg_table->descriptors
+                                        + page_shift),
+                                vmas);
+                        up_read(&(current->mm->mmap_sem));
+
+                        if ((pages <= 0) ||
+                                (pages != (pages_to_get - page_shift))) {
+                                dprintk(KERN_ERR "tf_fill_descriptor_table:"
+                                        " get_user_pages got %d pages while "
+                                        "trying to get %d pages!\n",
+                                        pages, pages_to_get - page_shift);
+                                ret = -EFAULT;
+                                goto error;
+                        }
+
+                        for (j = page_shift;
+                                  j < page_shift + pages;
+                                  j++) {
+                                /* Get the actual L2 descriptors */
+                                tf_get_l2_page_descriptor(
+                                        &coarse_pg_table->descriptors[j],
+                                        flags,
+                                        current->mm);
+                                /*
+                                 * Reject Strongly-Ordered or Device Memory
+                                 */
+#define IS_STRONGLY_ORDERED_OR_DEVICE_MEM(x) \
+        ((((x) & L2_TEX_C_B_MASK) == L2_TEX_C_B_STRONGLY_ORDERED) || \
+         (((x) & L2_TEX_C_B_MASK) == L2_TEX_C_B_SHARED_DEVICE) || \
+         (((x) & L2_TEX_C_B_MASK) == L2_TEX_C_B_NON_SHARED_DEVICE))
+
+                                if (IS_STRONGLY_ORDERED_OR_DEVICE_MEM(
+                                        coarse_pg_table->
+                                                descriptors[j])) {
+                                        dprintk(KERN_ERR
+                                                "tf_fill_descriptor_table:"
+                                                " descriptor 0x%08X use "
+                                                "strongly-ordered or device "
+                                                "memory. Rejecting!\n",
+                                                coarse_pg_table->
+                                                        descriptors[j]);
+                                        ret = -EFAULT;
+                                        goto error;
+                                }
+                        }
+                } else if (is_vmalloc_addr((void *)buffer_offset_vaddr)) {
+                        /* Kernel-space memory obtained through vmalloc */
+                        dprintk(KERN_INFO
+                                "tf_fill_descriptor_table: "
+                                "vmalloc'ed buffer starting at %p\n",
+                               (void *)buffer_offset_vaddr);
+                        for (j = page_shift; j < pages_to_get; j++) {
+                                struct page *page;
+                                void *addr =
+                                        (void *)(buffer_offset_vaddr +
+                                                (j - page_shift) * PAGE_SIZE);
+                                page = vmalloc_to_page(addr);
+                                if (page == NULL) {
+                                        dprintk(KERN_ERR
+                                                "tf_fill_descriptor_table: "
+                                                "cannot map %p (vmalloc) "
+                                                "to page\n",
+                                                addr);
+                                        ret = -EFAULT;
+                                        goto error;
+                                }
+                                coarse_pg_table->descriptors[j] = (u32)page;
+                                get_page(page);
+
+                                /* change coarse page "page address" */
+                                tf_get_l2_page_descriptor(
+                                        &coarse_pg_table->descriptors[j],
+                                        flags,
+                                        &init_mm);
+                        }
+                } else {
+                        /* Kernel-space memory given by a virtual address */
+                        dprintk(KERN_INFO
+                                "tf_fill_descriptor_table: "
+                                "buffer starting at virtual address %p\n",
+                               (void *)buffer_offset_vaddr);
+                        for (j = page_shift; j < pages_to_get; j++) {
+                                struct page *page;
+                                void *addr =
+                                        (void *)(buffer_offset_vaddr +
+                                                (j - page_shift) * PAGE_SIZE);
+                                page = virt_to_page(addr);
+                                if (page == NULL) {
+                                        dprintk(KERN_ERR
+                                                "tf_fill_descriptor_table: "
+                                                "cannot map %p (virtual) "
+                                                "to page\n",
+                                                addr);
+                                        ret = -EFAULT;
+                                        goto error;
+                                }
+                                coarse_pg_table->descriptors[j] = (u32)page;
+                                get_page(page);
+
+                                /* change coarse page "page address" */
+                                tf_get_l2_page_descriptor(
+                                        &coarse_pg_table->descriptors[j],
+                                        flags,
+                                        &init_mm);
+                        }
+                }
+
+                dmac_flush_range((void *)coarse_pg_table->descriptors,
+                   (void *)(((u32)(coarse_pg_table->descriptors)) +
+                   TF_DESCRIPTOR_TABLE_CAPACITY * sizeof(u32)));
+
+                outer_clean_range(
+                        __pa(coarse_pg_table->descriptors),
+                        __pa(coarse_pg_table->descriptors) +
+                        TF_DESCRIPTOR_TABLE_CAPACITY * sizeof(u32));
+                wmb();
+
+                /* Update the coarse page table address */
+                descriptors[coarse_page_index] =
+                        tf_get_l1_coarse_descriptor(
+                                coarse_pg_table->descriptors);
+
+                /*
+                 * The next coarse page has no page shift, reset the
+                 * page_shift
+                 */
+                page_shift = 0;
+        }
+
+        *descriptor_count = coarse_page_count;
+        shmem_desc->coarse_pg_table_count = coarse_page_count;
+
+#ifdef DEBUG_COARSE_TABLES
+        printk(KERN_DEBUG "ntf_fill_descriptor_table - size=0x%08X "
+                "numberOfCoarsePages=%d\n", buffer_size,
+                shmem_desc->coarse_pg_table_count);
+        for (coarse_page_index = 0;
+             coarse_page_index < shmem_desc->coarse_pg_table_count;
+             coarse_page_index++) {
+                u32 j;
+                struct tf_coarse_page_table *coarse_page_table =
+                        shmem_desc->coarse_pg_table[coarse_page_index];
+
+                printk(KERN_DEBUG "  Descriptor=%p address=%p index=%d\n",
+                        coarse_page_table,
+                        coarse_page_table->descriptors,
+                        coarse_page_index);
+                for (j = 0;
+                     j < TF_DESCRIPTOR_TABLE_CAPACITY;
+                     j += 8) {
+                        int k;
+                        printk(KERN_DEBUG "    ");
+                        for (k = j; k < j + 8; k++)
+                                printk(KERN_DEBUG "0x%08X ",
+                                        coarse_page_table->descriptors[k]);
+                        printk(KERN_DEBUG "\n");
+                }
+        }
+        printk(KERN_DEBUG "ntf_fill_descriptor_table() - done\n\n");
+#endif
+
+        return 0;
+
+error:
+        tf_cleanup_shared_memory(
+                        alloc_context,
+                        shmem_desc,
+                        0);
+
+        return ret;
+}
+
+
+/*----------------------------------------------------------------------------
+ * Standard communication operations
+ *----------------------------------------------------------------------------*/
+
+u8 *tf_get_description(struct tf_comm *comm)
+{
+        if (test_bit(TF_COMM_FLAG_L1_SHARED_ALLOCATED, &(comm->flags)))
+                return comm->l1_buffer->version_description;
+
+        return NULL;
+}
+
+/*
+ * Returns a non-zero value if the specified S-timeout has expired, zero
+ * otherwise.
+ *
+ * The placeholder referenced to by relative_timeout_jiffies gives the relative
+ * timeout from now in jiffies. It is set to zero if the S-timeout has expired,
+ * or to MAX_SCHEDULE_TIMEOUT if the S-timeout is infinite.
+ */
+static int tf_test_s_timeout(
+                u64 timeout,
+                signed long *relative_timeout_jiffies)
+{
+        struct timeval now;
+        u64 time64;
+
+        *relative_timeout_jiffies = 0;
+
+        /* immediate timeout */
+        if (timeout == TIME_IMMEDIATE)
+                return 1;
+
+        /* infinite timeout */
+        if (timeout == TIME_INFINITE) {
+                dprintk(KERN_DEBUG "tf_test_s_timeout: "
+                        "timeout is infinite\n");
+                *relative_timeout_jiffies = MAX_SCHEDULE_TIMEOUT;
+                return 0;
+        }
+
+        do_gettimeofday(&now);
+        time64 = now.tv_sec;
+        /* will not overflow as operations are done on 64bit values */
+        time64 = (time64 * 1000) + (now.tv_usec / 1000);
+
+        /* timeout expired */
+        if (time64 >= timeout) {
+                dprintk(KERN_DEBUG "tf_test_s_timeout: timeout expired\n");
+                return 1;
+        }
+
+        /*
+         * finite timeout, compute relative_timeout_jiffies
+         */
+        /* will not overflow as time64 < timeout */
+        timeout -= time64;
+
+        /* guarantee *relative_timeout_jiffies is a valid timeout */
+        if ((timeout >> 32) != 0)
+                *relative_timeout_jiffies = MAX_JIFFY_OFFSET;
+        else
+                *relative_timeout_jiffies =
+                        msecs_to_jiffies((unsigned int) timeout);
+
+        dprintk(KERN_DEBUG "tf_test_s_timeout: timeout is 0x%lx\n",
+                *relative_timeout_jiffies);
+        return 0;
+}
+
+static void tf_copy_answers(struct tf_comm *comm)
+{
+        u32 first_answer;
+        u32 first_free_answer;
+        struct tf_answer_struct *answerStructureTemp;
+
+        if (test_bit(TF_COMM_FLAG_L1_SHARED_ALLOCATED, &(comm->flags))) {
+                spin_lock(&comm->lock);
+                first_free_answer = tf_read_reg32(
+                        &comm->l1_buffer->first_free_answer);
+                first_answer = tf_read_reg32(
+                        &comm->l1_buffer->first_answer);
+
+                while (first_answer != first_free_answer) {
+                        /* answer queue not empty */
+                        union tf_answer sComAnswer;
+                        struct tf_answer_header  header;
+
+                        /*
+                         * the size of the command in words of 32bit, not in
+                         * bytes
+                         */
+                        u32 command_size;
+                        u32 i;
+                        u32 *temp = (uint32_t *) &header;
+
+                        dprintk(KERN_INFO
+                                "[pid=%d] tf_copy_answers(%p): "
+                                "Read answers from L1\n",
+                                current->pid, comm);
+
+                        /* Read the answer header */
+                        for (i = 0;
+                             i < sizeof(struct tf_answer_header)/sizeof(u32);
+                               i++)
+                                temp[i] = comm->l1_buffer->answer_queue[
+                                        (first_answer + i) %
+                                                TF_S_ANSWER_QUEUE_CAPACITY];
+
+                        /* Read the answer from the L1_Buffer*/
+                        command_size = header.message_size +
+                                sizeof(struct tf_answer_header)/sizeof(u32);
+                        temp = (uint32_t *) &sComAnswer;
+                        for (i = 0; i < command_size; i++)
+                                temp[i] = comm->l1_buffer->answer_queue[
+                                        (first_answer + i) %
+                                                TF_S_ANSWER_QUEUE_CAPACITY];
+
+                        answerStructureTemp = (struct tf_answer_struct *)
+                                sComAnswer.header.operation_id;
+
+                        tf_dump_answer(&sComAnswer);
+
+                        memcpy(answerStructureTemp->answer, &sComAnswer,
+                                command_size * sizeof(u32));
+                        answerStructureTemp->answer_copied = true;
+
+                        first_answer += command_size;
+                        tf_write_reg32(&comm->l1_buffer->first_answer,
+                                first_answer);
+                }
+                spin_unlock(&(comm->lock));
+        }
+}
+
+static void tf_copy_command(
+        struct tf_comm *comm,
+        union tf_command *command,
+        struct tf_connection *connection,
+        enum TF_COMMAND_STATE *command_status)
+{
+        if ((test_bit(TF_COMM_FLAG_L1_SHARED_ALLOCATED, &(comm->flags)))
+                && (command != NULL)) {
+                /*
+                 * Write the message in the message queue.
+                 */
+
+                if (*command_status == TF_COMMAND_STATE_PENDING) {
+                        u32 command_size;
+                        u32 queue_words_count;
+                        u32 i;
+                        u32 first_free_command;
+                        u32 first_command;
+
+                        spin_lock(&comm->lock);
+
+                        first_command = tf_read_reg32(
+                                &comm->l1_buffer->first_command);
+                        first_free_command = tf_read_reg32(
+                                &comm->l1_buffer->first_free_command);
+
+                        queue_words_count = first_free_command - first_command;
+                        command_size     = command->header.message_size +
+                                sizeof(struct tf_command_header)/sizeof(u32);
+                        if ((queue_words_count + command_size) <
+                                TF_N_MESSAGE_QUEUE_CAPACITY) {
+                                /*
+                                * Command queue is not full.
+                                * If the Command queue is full,
+                                * the command will be copied at
+                                * another iteration
+                                * of the current function.
+                                */
+
+                                /*
+                                * Change the conn state
+                                */
+                                if (connection == NULL)
+                                        goto copy;
+
+                                spin_lock(&(connection->state_lock));
+
+                                if ((connection->state ==
+                                TF_CONN_STATE_NO_DEVICE_CONTEXT)
+                                &&
+                                (command->header.message_type ==
+                                TF_MESSAGE_TYPE_CREATE_DEVICE_CONTEXT)) {
+
+                                        dprintk(KERN_INFO
+                                "tf_copy_command(%p):"
+                                "Conn state is DEVICE_CONTEXT_SENT\n",
+                                 connection);
+                                        connection->state =
+                        TF_CONN_STATE_CREATE_DEVICE_CONTEXT_SENT;
+                                } else if ((connection->state !=
+                                TF_CONN_STATE_VALID_DEVICE_CONTEXT)
+                                &&
+                                (command->header.message_type !=
+                                TF_MESSAGE_TYPE_CREATE_DEVICE_CONTEXT)) {
+                                        /* The connection
+                                        * is no longer valid.
+                                        * We may not send any command on it,
+                                        * not even another
+                                        * DESTROY_DEVICE_CONTEXT.
+                                        */
+                                        dprintk(KERN_INFO
+                                                "[pid=%d] tf_copy_command(%p): "
+                                                "Connection no longer valid."
+                                                "ABORT\n",
+                                                current->pid, connection);
+                                        *command_status =
+                                                TF_COMMAND_STATE_ABORTED;
+                                        spin_unlock(
+                                                &(connection->state_lock));
+                                        spin_unlock(
+                                                &comm->lock);
+                                        return;
+                                } else if (
+                                        (command->header.message_type ==
+                                TF_MESSAGE_TYPE_DESTROY_DEVICE_CONTEXT) &&
+                                (connection->state ==
+                                TF_CONN_STATE_VALID_DEVICE_CONTEXT)
+                                                ) {
+                                        dprintk(KERN_INFO
+                                        "[pid=%d] tf_copy_command(%p): "
+                                        "Conn state is "
+                                        "DESTROY_DEVICE_CONTEXT_SENT\n",
+                                        current->pid, connection);
+                                        connection->state =
+                        TF_CONN_STATE_DESTROY_DEVICE_CONTEXT_SENT;
+                                        }
+                                        spin_unlock(&(connection->state_lock));
+copy:
+                                        /*
+                                        * Copy the command to L1 Buffer
+                                        */
+                                        dprintk(KERN_INFO
+                                "[pid=%d] tf_copy_command(%p): "
+                                "Write Message in the queue\n",
+                                current->pid, command);
+                                        tf_dump_command(command);
+
+                                        for (i = 0; i < command_size; i++)
+                                                comm->l1_buffer->command_queue[
+                                                (first_free_command + i) %
+                                                TF_N_MESSAGE_QUEUE_CAPACITY] =
+                                                ((uint32_t *) command)[i];
+
+                                        *command_status =
+                                                TF_COMMAND_STATE_SENT;
+                                        first_free_command += command_size;
+
+                                        tf_write_reg32(
+                                                &comm->
+                                                l1_buffer->first_free_command,
+                                                first_free_command);
+                        }
+                        spin_unlock(&comm->lock);
+                }
+        }
+}
+
+/*
+ * Sends the specified message through the specified communication channel.
+ *
+ * This function sends the command and waits for the answer
+ *
+ * Returns zero upon successful completion, or an appropriate error code upon
+ * failure.
+ */
+static int tf_send_recv(struct tf_comm *comm,
+        union tf_command *command,
+        struct tf_answer_struct *answerStruct,
+        struct tf_connection *connection,
+        int bKillable
+        )
+{
+        int result;
+        u64 timeout;
+        signed long nRelativeTimeoutJiffies;
+        bool wait_prepared = false;
+        enum TF_COMMAND_STATE command_status = TF_COMMAND_STATE_PENDING;
+        DEFINE_WAIT(wait);
+#ifdef CONFIG_FREEZER
+        unsigned long saved_flags;
+#endif
+        dprintk(KERN_INFO "[pid=%d] tf_send_recv(%p)\n",
+                 current->pid, command);
+
+#ifdef CONFIG_TF_ZEBRA
+        tf_clock_timer_start();
+#endif
+
+#ifdef CONFIG_FREEZER
+        saved_flags = current->flags;
+        current->flags |= PF_FREEZER_NOSIG;
+#endif
+
+        /*
+         * Read all answers from the answer queue
+         */
+copy_answers:
+        tf_copy_answers(comm);
+
+        tf_copy_command(comm, command, connection, &command_status);
+
+        /*
+         * Notify all waiting threads
+         */
+        wake_up(&(comm->wait_queue));
+
+#ifdef CONFIG_FREEZER
+        if (unlikely(freezing(current))) {
+
+                dprintk(KERN_INFO
+                        "Entering refrigerator.\n");
+                refrigerator();
+                dprintk(KERN_INFO
+                        "Left refrigerator.\n");
+                goto copy_answers;
+        }
+#endif
+
+#ifndef CONFIG_PREEMPT
+        if (need_resched())
+                schedule();
+#endif
+
+#ifdef CONFIG_TF_ZEBRA
+        /*
+         * Handle RPC (if any)
+         */
+        if (tf_rpc_execute(comm) == RPC_NON_YIELD)
+                goto schedule_secure_world;
+#endif
+
+        /*
+         * Join wait queue
+         */
+        /*dprintk(KERN_INFO "[pid=%d] tf_send_recv(%p): Prepare to wait\n",
+                current->pid, command);*/
+        prepare_to_wait(&comm->wait_queue, &wait,
+                        bKillable ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
+        wait_prepared = true;
+
+        /*
+         * Check if our answer is available
+         */
+        if (command_status == TF_COMMAND_STATE_ABORTED) {
+                /* Not waiting for an answer, return error code */
+                result = -EINTR;
+                dprintk(KERN_ERR "[pid=%d] tf_send_recv: "
+                        "Command status is ABORTED."
+                        "Exit with 0x%x\n",
+                        current->pid, result);
+                goto exit;
+        }
+        if (answerStruct->answer_copied) {
+                dprintk(KERN_INFO "[pid=%d] tf_send_recv: "
+                        "Received answer (type 0x%02X)\n",
+                        current->pid,
+                        answerStruct->answer->header.message_type);
+                result = 0;
+                goto exit;
+        }
+
+        /*
+         * Check if a signal is pending
+         */
+        if (bKillable && (sigkill_pending())) {
+                if (command_status == TF_COMMAND_STATE_PENDING)
+                        /*Command was not sent. */
+                        result = -EINTR;
+                else
+                        /* Command was sent but no answer was received yet. */
+                        result = -EIO;
+
+                dprintk(KERN_ERR "[pid=%d] tf_send_recv: "
+                        "Signal Pending. Return error %d\n",
+                        current->pid, result);
+                goto exit;
+        }
+
+        /*
+         * Check if secure world is schedulable. It is schedulable if at
+         * least one of the following conditions holds:
+         * + it is still initializing (TF_COMM_FLAG_L1_SHARED_ALLOCATED
+         *   is not set);
+         * + there is a command in the queue;
+         * + the secure world timeout is zero.
+         */
+        if (test_bit(TF_COMM_FLAG_L1_SHARED_ALLOCATED, &(comm->flags))) {
+                u32 first_free_command;
+                u32 first_command;
+                spin_lock(&comm->lock);
+                first_command = tf_read_reg32(
+                        &comm->l1_buffer->first_command);
+                first_free_command = tf_read_reg32(
+                        &comm->l1_buffer->first_free_command);
+                spin_unlock(&comm->lock);
+                tf_read_timeout(comm, &timeout);
+                if ((first_free_command == first_command) &&
+                         (tf_test_s_timeout(timeout,
+                        &nRelativeTimeoutJiffies) == 0))
+                        /*
+                         * If command queue is empty and if timeout has not
+                         * expired secure world is not schedulable
+                         */
+                        goto wait;
+        }
+
+        finish_wait(&comm->wait_queue, &wait);
+        wait_prepared = false;
+
+        /*
+         * Yield to the Secure World
+         */
+#ifdef CONFIG_TF_ZEBRA
+schedule_secure_world:
+#endif
+
+        result = tf_schedule_secure_world(comm);
+        if (result < 0)
+                goto exit;
+        goto copy_answers;
+
+wait:
+        if (bKillable && (sigkill_pending())) {
+                if (command_status == TF_COMMAND_STATE_PENDING)
+                        result = -EINTR; /* Command was not sent. */
+                else
+                        /* Command was sent but no answer was received yet. */
+                        result = -EIO;
+
+                dprintk(KERN_ERR "[pid=%d] tf_send_recv: "
+                        "Signal Pending while waiting. Return error %d\n",
+                        current->pid, result);
+                goto exit;
+        }
+
+        if (nRelativeTimeoutJiffies == MAX_SCHEDULE_TIMEOUT)
+                dprintk(KERN_INFO "[pid=%d] tf_send_recv: "
+                        "prepare to sleep infinitely\n", current->pid);
+        else
+                dprintk(KERN_INFO "tf_send_recv: "
+                        "prepare to sleep 0x%lx jiffies\n",
+                        nRelativeTimeoutJiffies);
+
+        /* go to sleep */
+        if (schedule_timeout(nRelativeTimeoutJiffies) == 0)
+                dprintk(KERN_INFO
+                        "tf_send_recv: timeout expired\n");
+        else
+                dprintk(KERN_INFO
+                        "tf_send_recv: signal delivered\n");
+
+        finish_wait(&comm->wait_queue, &wait);
+        wait_prepared = false;
+        goto copy_answers;
+
+exit:
+        if (wait_prepared) {
+                finish_wait(&comm->wait_queue, &wait);
+                wait_prepared = false;
+        }
+
+#ifdef CONFIG_FREEZER
+        current->flags &= ~(PF_FREEZER_NOSIG);
+        current->flags |= (saved_flags & PF_FREEZER_NOSIG);
+#endif
+
+        return result;
+}
+
+/*
+ * Sends the specified message through the specified communication channel.
+ *
+ * This function sends the message and waits for the corresponding answer
+ * It may return if a signal needs to be delivered.
+ *
+ * Returns zero upon successful completion, or an appropriate error code upon
+ * failure.
+ */
+int tf_send_receive(struct tf_comm *comm,
+          union tf_command *command,
+          union tf_answer *answer,
+          struct tf_connection *connection,
+          bool bKillable)
+{
+        int error;
+        struct tf_answer_struct answerStructure;
+#ifdef CONFIG_SMP
+        long ret_affinity;
+        cpumask_t saved_cpu_mask;
+        cpumask_t local_cpu_mask = CPU_MASK_NONE;
+#endif
+
+        answerStructure.answer = answer;
+        answerStructure.answer_copied = false;
+
+        if (command != NULL)
+                command->header.operation_id = (u32) &answerStructure;
+
+        dprintk(KERN_INFO "tf_send_receive\n");
+
+#ifdef CONFIG_TF_ZEBRA
+        if (!test_bit(TF_COMM_FLAG_PA_AVAILABLE, &comm->flags)) {
+                dprintk(KERN_ERR "tf_send_receive(%p): "
+                        "Secure world not started\n", comm);
+
+                return -EFAULT;
+        }
+#endif
+
+        if (test_bit(TF_COMM_FLAG_TERMINATING, &(comm->flags)) != 0) {
+                dprintk(KERN_DEBUG
+                        "tf_send_receive: Flag Terminating is set\n");
+                return 0;
+        }
+
+#ifdef CONFIG_SMP
+        cpu_set(0, local_cpu_mask);
+        sched_getaffinity(0, &saved_cpu_mask);
+        ret_affinity = sched_setaffinity(0, &local_cpu_mask);
+        if (ret_affinity != 0)
+                dprintk(KERN_ERR "sched_setaffinity #1 -> 0x%lX", ret_affinity);
+#endif
+
+
+        /*
+         * Send the command
+         */
+        error = tf_send_recv(comm,
+                command, &answerStructure, connection, bKillable);
+
+        if (!bKillable && sigkill_pending()) {
+                if ((command->header.message_type ==
+                        TF_MESSAGE_TYPE_CREATE_DEVICE_CONTEXT) &&
+                        (answer->create_device_context.error_code ==
+                                S_SUCCESS)) {
+
+                        /*
+                         * CREATE_DEVICE_CONTEXT was interrupted.
+                         */
+                        dprintk(KERN_INFO "tf_send_receive: "
+                                "sending DESTROY_DEVICE_CONTEXT\n");
+                        answerStructure.answer =  answer;
+                        answerStructure.answer_copied = false;
+
+                        command->header.message_type =
+                                TF_MESSAGE_TYPE_DESTROY_DEVICE_CONTEXT;
+                        command->header.message_size =
+                                (sizeof(struct
+                                        tf_command_destroy_device_context) -
+                                 sizeof(struct tf_command_header))/sizeof(u32);
+                        command->header.operation_id =
+                                (u32) &answerStructure;
+                        command->destroy_device_context.device_context =
+                                answer->create_device_context.
+                                        device_context;
+
+                        goto destroy_context;
+                }
+        }
+
+        if (error == 0) {
+                /*
+                 * tf_send_recv returned Success.
+                 */
+                if (command->header.message_type ==
+                TF_MESSAGE_TYPE_CREATE_DEVICE_CONTEXT) {
+                        spin_lock(&(connection->state_lock));
+                        connection->state = TF_CONN_STATE_VALID_DEVICE_CONTEXT;
+                        spin_unlock(&(connection->state_lock));
+                } else if (command->header.message_type ==
+                TF_MESSAGE_TYPE_DESTROY_DEVICE_CONTEXT) {
+                        spin_lock(&(connection->state_lock));
+                        connection->state = TF_CONN_STATE_NO_DEVICE_CONTEXT;
+                        spin_unlock(&(connection->state_lock));
+                }
+        } else if (error  == -EINTR) {
+                /*
+                * No command was sent, return failure.
+                */
+                dprintk(KERN_ERR
+                        "tf_send_receive: "
+                        "tf_send_recv failed (error %d) !\n",
+                        error);
+        } else if (error  == -EIO) {
+                /*
+                * A command was sent but its answer is still pending.
+                */
+
+                /* means bKillable is true */
+                dprintk(KERN_ERR
+                        "tf_send_receive: "
+                        "tf_send_recv interrupted (error %d)."
+                        "Send DESTROY_DEVICE_CONTEXT.\n", error);
+
+                /* Send the DESTROY_DEVICE_CONTEXT. */
+                answerStructure.answer =  answer;
+                answerStructure.answer_copied = false;
+
+                command->header.message_type =
+                        TF_MESSAGE_TYPE_DESTROY_DEVICE_CONTEXT;
+                command->header.message_size =
+                        (sizeof(struct tf_command_destroy_device_context) -
+                                sizeof(struct tf_command_header))/sizeof(u32);
+                command->header.operation_id =
+                        (u32) &answerStructure;
+                command->destroy_device_context.device_context =
+                        connection->device_context;
+
+                error = tf_send_recv(comm,
+                        command, &answerStructure, connection, false);
+                if (error == -EINTR) {
+                        /*
+                        * Another thread already sent
+                        * DESTROY_DEVICE_CONTEXT.
+                        * We must still wait for the answer
+                        * to the original command.
+                        */
+                        command = NULL;
+                        goto destroy_context;
+                } else {
+                         /* An answer was received.
+                         * Check if it is the answer
+                         * to the DESTROY_DEVICE_CONTEXT.
+                         */
+                         spin_lock(&comm->lock);
+                         if (answer->header.message_type !=
+                         TF_MESSAGE_TYPE_DESTROY_DEVICE_CONTEXT) {
+                                answerStructure.answer_copied = false;
+                         }
+                         spin_unlock(&comm->lock);
+                         if (!answerStructure.answer_copied) {
+                                /* Answer to DESTROY_DEVICE_CONTEXT
+                                * was not yet received.
+                                * Wait for the answer.
+                                */
+                                dprintk(KERN_INFO
+                                        "[pid=%d] tf_send_receive:"
+                                        "Answer to DESTROY_DEVICE_CONTEXT"
+                                        "not yet received.Retry\n",
+                                        current->pid);
+                                command = NULL;
+                                goto destroy_context;
+                         }
+                }
+        }
+
+        dprintk(KERN_INFO "tf_send_receive(): Message answer ready\n");
+        goto exit;
+
+destroy_context:
+        error = tf_send_recv(comm,
+        command, &answerStructure, connection, false);
+
+        /*
+         * tf_send_recv cannot return an error because
+         * it's not killable and not within a connection
+         */
+        BUG_ON(error != 0);
+
+        /* Reset the state, so a new CREATE DEVICE CONTEXT can be sent */
+        spin_lock(&(connection->state_lock));
+        connection->state = TF_CONN_STATE_NO_DEVICE_CONTEXT;
+        spin_unlock(&(connection->state_lock));
+
+exit:
+
+#ifdef CONFIG_SMP
+        ret_affinity = sched_setaffinity(0, &saved_cpu_mask);
+        if (ret_affinity != 0)
+                dprintk(KERN_ERR "sched_setaffinity #2 -> 0x%lX", ret_affinity);
+#endif
+        return error;
+}
+
+/*----------------------------------------------------------------------------
+ * Power management
+ *----------------------------------------------------------------------------*/
+
+
+/*
+ * Handles all the power management calls.
+ * The operation is the type of power management
+ * operation to be performed.
+ *
+ * This routine will only return if a failure occured or if
+ * the required opwer management is of type "resume".
+ * "Hibernate" and "Shutdown" should lock when doing the
+ * corresponding SMC to the Secure World
+ */
+int tf_power_management(struct tf_comm *comm,
+        enum TF_POWER_OPERATION operation)
+{
+        u32 status;
+        int error = 0;
+
+        dprintk(KERN_INFO "tf_power_management(%d)\n", operation);
+
+#ifdef CONFIG_TF_ZEBRA
+        if (!test_bit(TF_COMM_FLAG_PA_AVAILABLE, &comm->flags)) {
+                dprintk(KERN_INFO "tf_power_management(%p): "
+                        "succeeded (not started)\n", comm);
+
+                return 0;
+        }
+#endif
+
+        status = ((tf_read_reg32(&(comm->l1_buffer->status_s))
+                & TF_STATUS_POWER_STATE_MASK)
+                >> TF_STATUS_POWER_STATE_SHIFT);
+
+        switch (operation) {
+        case TF_POWER_OPERATION_SHUTDOWN:
+                switch (status) {
+                case TF_POWER_MODE_ACTIVE:
+                        error = tf_pm_shutdown(comm);
+
+                        if (error) {
+                                dprintk(KERN_ERR "tf_power_management(): "
+                                        "Failed with error code 0x%08x\n",
+                                        error);
+                                goto error;
+                        }
+                        break;
+
+                default:
+                        goto not_allowed;
+                }
+                break;
+
+        case TF_POWER_OPERATION_HIBERNATE:
+                switch (status) {
+                case TF_POWER_MODE_ACTIVE:
+                        error = tf_pm_hibernate(comm);
+
+                        if (error) {
+                                dprintk(KERN_ERR "tf_power_management(): "
+                                        "Failed with error code 0x%08x\n",
+                                        error);
+                                goto error;
+                        }
+                        break;
+
+                default:
+                        goto not_allowed;
+                }
+                break;
+
+        case TF_POWER_OPERATION_RESUME:
+                error = tf_pm_resume(comm);
+
+                if (error != 0) {
+                        dprintk(KERN_ERR "tf_power_management(): "
+                                "Failed with error code 0x%08x\n",
+                                error);
+                        goto error;
+                }
+                break;
+        }
+
+        dprintk(KERN_INFO "tf_power_management(): succeeded\n");
+        return 0;
+
+not_allowed:
+        dprintk(KERN_ERR "tf_power_management(): "
+                "Power command not allowed in current "
+                "Secure World state %d\n", status);
+        error = -ENOTTY;
+error:
+        return error;
+}
+
diff --git a/security/tf_driver/tf_comm.h b/security/tf_driver/tf_comm.h
new file mode 100644
index 00000000000..8921dc1d1be
--- /dev/null
+++ b/security/tf_driver/tf_comm.h
@@ -0,0 +1,202 @@
+/**
+ * Copyright (c) 2011 Trusted Logic S.A.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#ifndef __TF_COMM_H__
+#define __TF_COMM_H__
+
+#include "tf_defs.h"
+#include "tf_protocol.h"
+
+/*----------------------------------------------------------------------------
+ * Misc
+ *----------------------------------------------------------------------------*/
+
+void tf_set_current_time(struct tf_comm *comm);
+
+/*
+ * Atomic accesses to 32-bit variables in the L1 Shared buffer
+ */
+static inline u32 tf_read_reg32(const u32 *comm_buffer)
+{
+        u32 result;
+
+        __asm__ __volatile__("@ tf_read_reg32\n"
+                "ldrex %0, [%1]\n"
+                : "=&r" (result)
+                : "r" (comm_buffer)
+        );
+
+        return result;
+}
+
+static inline void tf_write_reg32(void *comm_buffer, u32 value)
+{
+        u32 tmp;
+
+        __asm__ __volatile__("@ tf_write_reg32\n"
+                "1:     ldrex %0, [%2]\n"
+                "       strex %0, %1, [%2]\n"
+                "       teq   %0, #0\n"
+                "       bne   1b"
+                : "=&r" (tmp)
+                : "r" (value), "r" (comm_buffer)
+                : "cc"
+        );
+}
+
+/*
+ * Atomic accesses to 64-bit variables in the L1 Shared buffer
+ */
+static inline u64 tf_read_reg64(void *comm_buffer)
+{
+        u64 result;
+
+        __asm__ __volatile__("@ tf_read_reg64\n"
+                "ldrexd %0, [%1]\n"
+                : "=&r" (result)
+                : "r" (comm_buffer)
+        );
+
+        return result;
+}
+
+static inline void tf_write_reg64(void *comm_buffer, u64 value)
+{
+        u64 tmp;
+
+        __asm__ __volatile__("@ tf_write_reg64\n"
+                "1:     ldrexd %0, [%2]\n"
+                "       strexd %0, %1, [%2]\n"
+                "       teq    %0, #0\n"
+                "       bne    1b"
+                : "=&r" (tmp)
+                : "r" (value), "r" (comm_buffer)
+                : "cc"
+        );
+}
+
+/*----------------------------------------------------------------------------
+ * SMC operations
+ *----------------------------------------------------------------------------*/
+
+/* RPC return values */
+#define RPC_NO          0x00    /* No RPC to execute */
+#define RPC_YIELD       0x01    /* Yield RPC */
+#define RPC_NON_YIELD   0x02    /* non-Yield RPC */
+
+int tf_rpc_execute(struct tf_comm *comm);
+
+/*----------------------------------------------------------------------------
+ * Shared memory related operations
+ *----------------------------------------------------------------------------*/
+
+#define L1_DESCRIPTOR_FAULT            (0x00000000)
+#define L2_DESCRIPTOR_FAULT            (0x00000000)
+
+#define L2_DESCRIPTOR_ADDR_MASK         (0xFFFFF000)
+
+#define DESCRIPTOR_V13_12_MASK      (0x3 << PAGE_SHIFT)
+#define DESCRIPTOR_V13_12_GET(a)    ((a & DESCRIPTOR_V13_12_MASK) >> PAGE_SHIFT)
+
+struct tf_coarse_page_table *tf_alloc_coarse_page_table(
+        struct tf_coarse_page_table_allocation_context *alloc_context,
+        u32 type);
+
+void tf_free_coarse_page_table(
+        struct tf_coarse_page_table_allocation_context *alloc_context,
+        struct tf_coarse_page_table *coarse_pg_table,
+        int force);
+
+void tf_init_coarse_page_table_allocator(
+        struct tf_coarse_page_table_allocation_context *alloc_context);
+
+void tf_release_coarse_page_table_allocator(
+        struct tf_coarse_page_table_allocation_context *alloc_context);
+
+struct page *tf_l2_page_descriptor_to_page(u32 l2_page_descriptor);
+
+u32 tf_get_l2_descriptor_common(u32 vaddr, struct mm_struct *mm);
+
+void tf_cleanup_shared_memory(
+        struct tf_coarse_page_table_allocation_context *alloc_context,
+        struct tf_shmem_desc *shmem_desc,
+        u32 full_cleanup);
+
+int tf_fill_descriptor_table(
+        struct tf_coarse_page_table_allocation_context *alloc_context,
+        struct tf_shmem_desc *shmem_desc,
+        u32 buffer,
+        struct vm_area_struct **vmas,
+        u32 descriptors[TF_MAX_COARSE_PAGES],
+        u32 buffer_size,
+        u32 *buffer_start_offset,
+        bool in_user_space,
+        u32 flags,
+        u32 *descriptor_count);
+
+/*----------------------------------------------------------------------------
+ * Standard communication operations
+ *----------------------------------------------------------------------------*/
+
+int tf_schedule_secure_world(struct tf_comm *comm);
+
+int tf_send_receive(
+        struct tf_comm *comm,
+        union tf_command *command,
+        union tf_answer *answer,
+        struct tf_connection *connection,
+        bool bKillable);
+
+
+/**
+ * get a pointer to the secure world description.
+ * This points directly into the L1 shared buffer
+ * and is valid only once the communication has
+ * been initialized
+ **/
+u8 *tf_get_description(struct tf_comm *comm);
+
+/*----------------------------------------------------------------------------
+ * Power management
+ *----------------------------------------------------------------------------*/
+
+enum TF_POWER_OPERATION {
+        TF_POWER_OPERATION_HIBERNATE = 1,
+        TF_POWER_OPERATION_SHUTDOWN = 2,
+        TF_POWER_OPERATION_RESUME = 3,
+};
+
+int tf_pm_hibernate(struct tf_comm *comm);
+int tf_pm_resume(struct tf_comm *comm);
+int tf_pm_shutdown(struct tf_comm *comm);
+
+int tf_power_management(struct tf_comm *comm,
+        enum TF_POWER_OPERATION operation);
+
+
+/*----------------------------------------------------------------------------
+ * Communication initialization and termination
+ *----------------------------------------------------------------------------*/
+
+int tf_init(struct tf_comm *comm);
+
+void tf_terminate(struct tf_comm *comm);
+
+
+#endif  /* __TF_COMM_H__ */
diff --git a/security/tf_driver/tf_comm_tz.c b/security/tf_driver/tf_comm_tz.c
new file mode 100644
index 00000000000..4c89de84acc
--- /dev/null
+++ b/security/tf_driver/tf_comm_tz.c
@@ -0,0 +1,885 @@
+/**
+ * Copyright (c) 2011 Trusted Logic S.A.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#include <asm/div64.h>
+#include <asm/system.h>
+#include <linux/version.h>
+#include <asm/cputype.h>
+#include <linux/interrupt.h>
+#include <linux/page-flags.h>
+#include <linux/pagemap.h>
+#include <linux/vmalloc.h>
+#include <linux/jiffies.h>
+
+#include "tf_defs.h"
+#include "tf_comm.h"
+#include "tf_protocol.h"
+#include "tf_util.h"
+#include "tf_conn.h"
+
+/*
+ * Structure common to all SMC operations
+ */
+struct tf_generic_smc {
+        u32 reg0;
+        u32 reg1;
+        u32 reg2;
+        u32 reg3;
+        u32 reg4;
+};
+
+/*----------------------------------------------------------------------------
+ * SMC operations
+ *----------------------------------------------------------------------------*/
+
+static inline void tf_smc_generic_call(
+        struct tf_generic_smc *generic_smc)
+{
+#ifdef CONFIG_SMP
+        long ret;
+        cpumask_t saved_cpu_mask;
+        cpumask_t local_cpu_mask = CPU_MASK_NONE;
+
+        cpu_set(0, local_cpu_mask);
+        sched_getaffinity(0, &saved_cpu_mask);
+        ret = sched_setaffinity(0, &local_cpu_mask);
+        if (ret != 0)
+                dprintk(KERN_ERR "sched_setaffinity #1 -> 0x%lX", ret);
+#endif
+
+        __asm__ volatile(
+                "mov r0, %2\n"
+                "mov r1, %3\n"
+                "mov r2, %4\n"
+                "mov r3, %5\n"
+                "mov r4, %6\n"
+                ".word    0xe1600070              @ SMC 0\n"
+                "mov %0, r0\n"
+                "mov %1, r1\n"
+                : "=r" (generic_smc->reg0), "=r" (generic_smc->reg1)
+                : "r" (generic_smc->reg0), "r" (generic_smc->reg1),
+                  "r" (generic_smc->reg2), "r" (generic_smc->reg3),
+                  "r" (generic_smc->reg4)
+                : "r0", "r1", "r2", "r3", "r4");
+
+#ifdef CONFIG_SMP
+                ret = sched_setaffinity(0, &saved_cpu_mask);
+                if (ret != 0)
+                        dprintk(KERN_ERR "sched_setaffinity #2 -> 0x%lX", ret);
+#endif
+}
+
+/*
+ * Calls the get protocol version SMC.
+ * Fills the parameter pProtocolVersion with the version number returned by the
+ * SMC
+ */
+static inline void tf_smc_get_protocol_version(u32 *protocol_version)
+{
+        struct tf_generic_smc generic_smc;
+
+        generic_smc.reg0 = TF_SMC_GET_PROTOCOL_VERSION;
+        generic_smc.reg1 = 0;
+        generic_smc.reg2 = 0;
+        generic_smc.reg3 = 0;
+        generic_smc.reg4 = 0;
+
+        tf_smc_generic_call(&generic_smc);
+        *protocol_version = generic_smc.reg1;
+}
+
+
+/*
+ * Calls the init SMC with the specified parameters.
+ * Returns zero upon successful completion, or an appropriate error code upon
+ * failure.
+ */
+static inline int tf_smc_init(u32 shared_page_descriptor)
+{
+        struct tf_generic_smc generic_smc;
+
+        generic_smc.reg0 = TF_SMC_INIT;
+        /* Descriptor for the layer 1 shared buffer */
+        generic_smc.reg1 = shared_page_descriptor;
+        generic_smc.reg2 = 0;
+        generic_smc.reg3 = 0;
+        generic_smc.reg4 = 0;
+
+        tf_smc_generic_call(&generic_smc);
+        if (generic_smc.reg0 != S_SUCCESS)
+                printk(KERN_ERR "tf_smc_init:"
+                        " r0=0x%08X upon return (expected 0x%08X)!\n",
+                        generic_smc.reg0,
+                        S_SUCCESS);
+
+        return generic_smc.reg0;
+}
+
+
+/*
+ * Calls the reset irq SMC.
+ */
+static inline void tf_smc_reset_irq(void)
+{
+        struct tf_generic_smc generic_smc;
+
+        generic_smc.reg0 = TF_SMC_RESET_IRQ;
+        generic_smc.reg1 = 0;
+        generic_smc.reg2 = 0;
+        generic_smc.reg3 = 0;
+        generic_smc.reg4 = 0;
+
+        tf_smc_generic_call(&generic_smc);
+}
+
+
+/*
+ * Calls the WAKE_UP SMC.
+ * Returns zero upon successful completion, or an appropriate error code upon
+ * failure.
+ */
+static inline int tf_smc_wake_up(u32 l1_shared_buffer_descriptor,
+        u32 shared_mem_start_offset,
+        u32 shared_mem_size)
+{
+        struct tf_generic_smc generic_smc;
+
+        generic_smc.reg0 = TF_SMC_WAKE_UP;
+        generic_smc.reg1 = shared_mem_start_offset;
+        /* long form command */
+        generic_smc.reg2 = shared_mem_size | 0x80000000;
+        generic_smc.reg3 = l1_shared_buffer_descriptor;
+        generic_smc.reg4 = 0;
+
+        tf_smc_generic_call(&generic_smc);
+
+        if (generic_smc.reg0 != S_SUCCESS)
+                printk(KERN_ERR "tf_smc_wake_up:"
+                        " r0=0x%08X upon return (expected 0x%08X)!\n",
+                        generic_smc.reg0,
+                        S_SUCCESS);
+
+        return generic_smc.reg0;
+}
+
+/*
+ * Calls the N-Yield SMC.
+ */
+static inline void tf_smc_nyield(void)
+{
+        struct tf_generic_smc generic_smc;
+
+        generic_smc.reg0 = TF_SMC_N_YIELD;
+        generic_smc.reg1 = 0;
+        generic_smc.reg2 = 0;
+        generic_smc.reg3 = 0;
+        generic_smc.reg4 = 0;
+
+        tf_smc_generic_call(&generic_smc);
+}
+
+/* Yields the Secure World */
+int tf_schedule_secure_world(struct tf_comm *comm)
+{
+        tf_set_current_time(comm);
+
+        /* yield to the Secure World */
+        tf_smc_nyield();
+
+        return 0;
+}
+
+/*
+ * Returns the L2 descriptor for the specified user page.
+ */
+
+#define L2_INIT_DESCRIPTOR_BASE           (0x00000003)
+#define L2_INIT_DESCRIPTOR_V13_12_SHIFT   (4)
+
+static u32 tf_get_l2init_descriptor(u32 vaddr)
+{
+        struct page *page;
+        u32 paddr;
+        u32 descriptor;
+
+        descriptor = L2_INIT_DESCRIPTOR_BASE;
+
+        /* get physical address and add to descriptor */
+        page = virt_to_page(vaddr);
+        paddr = page_to_phys(page);
+        descriptor |= (paddr & L2_DESCRIPTOR_ADDR_MASK);
+
+        /* Add virtual address v[13:12] bits to descriptor */
+        descriptor |= (DESCRIPTOR_V13_12_GET(vaddr)
+                << L2_INIT_DESCRIPTOR_V13_12_SHIFT);
+
+        descriptor |= tf_get_l2_descriptor_common(vaddr, &init_mm);
+
+
+        return descriptor;
+}
+
+
+/*----------------------------------------------------------------------------
+ * Power management
+ *----------------------------------------------------------------------------*/
+
+/*
+ * Free the memory used by the W3B buffer for the specified comm.
+ * This function does nothing if no W3B buffer is allocated for the device.
+ */
+static inline void tf_free_w3b(struct tf_comm *comm)
+{
+        tf_cleanup_shared_memory(
+                &(comm->w3b_cpt_alloc_context),
+                &(comm->w3b_shmem_desc),
+                0);
+
+        tf_release_coarse_page_table_allocator(&(comm->w3b_cpt_alloc_context));
+
+        internal_vfree((void *)comm->w3b);
+        comm->w3b = 0;
+        comm->w3b_shmem_size = 0;
+        clear_bit(TF_COMM_FLAG_W3B_ALLOCATED, &(comm->flags));
+}
+
+
+/*
+ * Allocates the W3B buffer for the specified comm.
+ * Returns zero upon successful completion, or an appropriate error code upon
+ * failure.
+ */
+static inline int tf_allocate_w3b(struct tf_comm *comm)
+{
+        int error;
+        u32 flags;
+        u32 config_flag_s;
+        u32 *w3b_descriptors;
+        u32 w3b_descriptor_count;
+        u32 w3b_current_size;
+
+        config_flag_s = tf_read_reg32(&comm->l1_buffer->config_flag_s);
+
+retry:
+        if ((test_bit(TF_COMM_FLAG_W3B_ALLOCATED, &(comm->flags))) == 0) {
+                /*
+                 * Initialize the shared memory for the W3B
+                 */
+                tf_init_coarse_page_table_allocator(
+                        &comm->w3b_cpt_alloc_context);
+        } else {
+                /*
+                 * The W3B is allocated but do we have to reallocate a bigger
+                 * one?
+                 */
+                /* Check H bit */
+                if ((config_flag_s & (1<<4)) != 0) {
+                        /* The size of the W3B may change after SMC_INIT */
+                        /* Read the current value */
+                        w3b_current_size = tf_read_reg32(
+                                &comm->l1_buffer->w3b_size_current_s);
+                        if (comm->w3b_shmem_size > w3b_current_size)
+                                return 0;
+
+                        tf_free_w3b(comm);
+                        goto retry;
+                } else {
+                        return 0;
+                }
+        }
+
+        /* check H bit */
+        if ((config_flag_s & (1<<4)) != 0)
+                /* The size of the W3B may change after SMC_INIT */
+                /* Read the current value */
+                comm->w3b_shmem_size = tf_read_reg32(
+                        &comm->l1_buffer->w3b_size_current_s);
+        else
+                comm->w3b_shmem_size = tf_read_reg32(
+                        &comm->l1_buffer->w3b_size_max_s);
+
+        comm->w3b = (u32) internal_vmalloc(comm->w3b_shmem_size);
+        if (comm->w3b == 0) {
+                printk(KERN_ERR "tf_allocate_w3b():"
+                        " Out of memory for W3B buffer (%u bytes)!\n",
+                        (unsigned int)(comm->w3b_shmem_size));
+                error = -ENOMEM;
+                goto error;
+        }
+
+        /* initialize the w3b_shmem_desc structure */
+        comm->w3b_shmem_desc.type = TF_SHMEM_TYPE_PM_HIBERNATE;
+        INIT_LIST_HEAD(&(comm->w3b_shmem_desc.list));
+
+        flags = (TF_SHMEM_TYPE_READ | TF_SHMEM_TYPE_WRITE);
+
+        /* directly point to the L1 shared buffer W3B descriptors */
+        w3b_descriptors = comm->l1_buffer->w3b_descriptors;
+
+        /*
+         * tf_fill_descriptor_table uses the following parameter as an
+         * IN/OUT
+         */
+
+        error = tf_fill_descriptor_table(
+                &(comm->w3b_cpt_alloc_context),
+                &(comm->w3b_shmem_desc),
+                comm->w3b,
+                NULL,
+                w3b_descriptors,
+                comm->w3b_shmem_size,
+                &(comm->w3b_shmem_offset),
+                false,
+                flags,
+                &w3b_descriptor_count);
+        if (error != 0) {
+                printk(KERN_ERR "tf_allocate_w3b():"
+                        " tf_fill_descriptor_table failed with "
+                        "error code 0x%08x!\n",
+                        error);
+                goto error;
+        }
+
+        set_bit(TF_COMM_FLAG_W3B_ALLOCATED, &(comm->flags));
+
+        /* successful completion */
+        return 0;
+
+error:
+        tf_free_w3b(comm);
+
+        return error;
+}
+
+/*
+ * Perform a Secure World shutdown operation.
+ * The routine does not return if the operation succeeds.
+ * the routine returns an appropriate error code if
+ * the operation fails.
+ */
+int tf_pm_shutdown(struct tf_comm *comm)
+{
+#ifdef CONFIG_TFN
+        /* this function is useless for the TEGRA product */
+        return 0;
+#else
+        int error;
+        union tf_command command;
+        union tf_answer answer;
+
+        dprintk(KERN_INFO "tf_pm_shutdown()\n");
+
+        memset(&command, 0, sizeof(command));
+
+        command.header.message_type = TF_MESSAGE_TYPE_MANAGEMENT;
+        command.header.message_size =
+                        (sizeof(struct tf_command_management) -
+                                sizeof(struct tf_command_header))/sizeof(u32);
+
+        command.management.command = TF_MANAGEMENT_SHUTDOWN;
+
+        error = tf_send_receive(
+                comm,
+                &command,
+                &answer,
+                NULL,
+                false);
+
+        if (error != 0) {
+                dprintk(KERN_ERR "tf_pm_shutdown(): "
+                        "tf_send_receive failed (error %d)!\n",
+                        error);
+                return error;
+        }
+
+#ifdef CONFIG_TF_DRIVER_DEBUG_SUPPORT
+        if (answer.header.error_code != 0)
+                dprintk(KERN_ERR "tf_driver: shutdown failed.\n");
+        else
+                dprintk(KERN_INFO "tf_driver: shutdown succeeded.\n");
+#endif
+
+        return answer.header.error_code;
+#endif
+}
+
+
+/*
+ * Perform a Secure World hibernate operation.
+ * The routine does not return if the operation succeeds.
+ * the routine returns an appropriate error code if
+ * the operation fails.
+ */
+int tf_pm_hibernate(struct tf_comm *comm)
+{
+#ifdef CONFIG_TFN
+        /* this function is useless for the TEGRA product */
+        return 0;
+#else
+        int error;
+        union tf_command command;
+        union tf_answer answer;
+        u32 first_command;
+        u32 first_free_command;
+
+        dprintk(KERN_INFO "tf_pm_hibernate()\n");
+
+        error = tf_allocate_w3b(comm);
+        if (error != 0) {
+                dprintk(KERN_ERR "tf_pm_hibernate(): "
+                        "tf_allocate_w3b failed (error %d)!\n",
+                        error);
+                return error;
+        }
+
+        /*
+         * As the polling thread is already hibernating, we
+         * should send the message and receive the answer ourself
+         */
+
+        /* build the "prepare to hibernate" message */
+        command.header.message_type = TF_MESSAGE_TYPE_MANAGEMENT;
+        command.management.command = TF_MANAGEMENT_HIBERNATE;
+        /* Long Form Command */
+        command.management.shared_mem_descriptors[0] = 0;
+        command.management.shared_mem_descriptors[1] = 0;
+        command.management.w3b_size =
+                comm->w3b_shmem_size | 0x80000000;
+        command.management.w3b_start_offset =
+                comm->w3b_shmem_offset;
+        command.header.operation_id = (u32) &answer;
+
+        tf_dump_command(&command);
+
+        /* find a slot to send the message in */
+
+        /* AFY: why not use the function tf_send_receive?? We are
+         * duplicating a lot of subtle code here. And it's not going to be
+         * tested because power management is currently not supported by the
+         * secure world. */
+        for (;;) {
+                int queue_words_count, command_size;
+
+                spin_lock(&(comm->lock));
+
+                first_command = tf_read_reg32(
+                        &comm->l1_buffer->first_command);
+                first_free_command = tf_read_reg32(
+                        &comm->l1_buffer->first_free_command);
+
+                queue_words_count = first_free_command - first_command;
+                command_size     = command.header.message_size
+                        + sizeof(struct tf_command_header);
+                if ((queue_words_count + command_size) <
+                                TF_N_MESSAGE_QUEUE_CAPACITY) {
+                        /* Command queue is not full */
+                        memcpy(&comm->l1_buffer->command_queue[
+                                first_free_command %
+                                        TF_N_MESSAGE_QUEUE_CAPACITY],
+                                &command,
+                                command_size * sizeof(u32));
+
+                        tf_write_reg32(&comm->l1_buffer->first_free_command,
+                                first_free_command + command_size);
+
+                        spin_unlock(&(comm->lock));
+                        break;
+                }
+
+                spin_unlock(&(comm->lock));
+                (void)tf_schedule_secure_world(comm);
+        }
+
+        /* now wait for the answer, dispatching other answers */
+        while (1) {
+                u32 first_answer;
+                u32 first_free_answer;
+
+                /* check all the answers */
+                first_free_answer = tf_read_reg32(
+                        &comm->l1_buffer->first_free_answer);
+                first_answer = tf_read_reg32(
+                        &comm->l1_buffer->first_answer);
+
+                if (first_answer != first_free_answer) {
+                        int bFoundAnswer = 0;
+
+                        do {
+                                /* answer queue not empty */
+                                union tf_answer tmp_answer;
+                                struct tf_answer_header header;
+                                /* size of the command in words of 32bit */
+                                int command_size;
+
+                                /* get the message_size */
+                                memcpy(&header,
+                                        &comm->l1_buffer->answer_queue[
+                                                first_answer %
+                                                TF_S_ANSWER_QUEUE_CAPACITY],
+                                        sizeof(struct tf_answer_header));
+                                command_size = header.message_size +
+                                        sizeof(struct tf_answer_header);
+
+                                /*
+                                 * NOTE: message_size is the number of words
+                                 * following the first word
+                                 */
+                                memcpy(&tmp_answer,
+                                        &comm->l1_buffer->answer_queue[
+                                                first_answer %
+                                                TF_S_ANSWER_QUEUE_CAPACITY],
+                                        command_size * sizeof(u32));
+
+                                tf_dump_answer(&tmp_answer);
+
+                                if (tmp_answer.header.operation_id ==
+                                                (u32) &answer) {
+                                        /*
+                                         * this is the answer to the "prepare to
+                                         * hibernate" message
+                                         */
+                                        memcpy(&answer,
+                                                &tmp_answer,
+                                                command_size * sizeof(u32));
+
+                                        bFoundAnswer = 1;
+                                        tf_write_reg32(
+                                                &comm->l1_buffer->first_answer,
+                                                first_answer + command_size);
+                                        break;
+                                } else {
+                                        /*
+                                         * this is a standard message answer,
+                                         * dispatch it
+                                         */
+                                        struct tf_answer_struct
+                                                *answerStructure;
+
+                                        answerStructure =
+                                                (struct tf_answer_struct *)
+                                                tmp_answer.header.operation_id;
+
+                                        memcpy(answerStructure->answer,
+                                                &tmp_answer,
+                                                command_size * sizeof(u32));
+
+                                        answerStructure->answer_copied = true;
+                                }
+
+                                tf_write_reg32(
+                                        &comm->l1_buffer->first_answer,
+                                        first_answer + command_size);
+                        } while (first_answer != first_free_answer);
+
+                        if (bFoundAnswer)
+                                break;
+                }
+
+                /*
+                 * since the Secure World is at least running the "prepare to
+                 * hibernate" message, its timeout must be immediate So there is
+                 * no need to check its timeout and schedule() the current
+                 * thread
+                 */
+                (void)tf_schedule_secure_world(comm);
+        } /* while (1) */
+
+        printk(KERN_INFO "tf_driver: hibernate.\n");
+        return 0;
+#endif
+}
+
+
+/*
+ * Perform a Secure World resume operation.
+ * The routine returns once the Secure World is active again
+ * or if an error occurs during the "resume" process
+ */
+int tf_pm_resume(struct tf_comm *comm)
+{
+#ifdef CONFIG_TFN
+        /* this function is useless for the TEGRA product */
+        return 0;
+#else
+        int error;
+        u32 status;
+
+        dprintk(KERN_INFO "tf_pm_resume()\n");
+
+        error = tf_smc_wake_up(
+                tf_get_l2init_descriptor((u32)comm->l1_buffer),
+                comm->w3b_shmem_offset,
+                comm->w3b_shmem_size);
+
+        if (error != 0) {
+                dprintk(KERN_ERR "tf_pm_resume(): "
+                        "tf_smc_wake_up failed (error %d)!\n",
+                        error);
+                return error;
+        }
+
+        status = ((tf_read_reg32(&(comm->l1_buffer->status_s))
+                & TF_STATUS_POWER_STATE_MASK)
+                >> TF_STATUS_POWER_STATE_SHIFT);
+
+        while ((status != TF_POWER_MODE_ACTIVE)
+                        && (status != TF_POWER_MODE_PANIC)) {
+                tf_smc_nyield();
+
+                status = ((tf_read_reg32(&(comm->l1_buffer->status_s))
+                        & TF_STATUS_POWER_STATE_MASK)
+                        >> TF_STATUS_POWER_STATE_SHIFT);
+
+                /*
+                 * As this may last quite a while, call the kernel scheduler to
+                 * hand over CPU for other operations
+                 */
+                schedule();
+        }
+
+        switch (status) {
+        case TF_POWER_MODE_ACTIVE:
+                break;
+
+        case TF_POWER_MODE_PANIC:
+                dprintk(KERN_ERR "tf_pm_resume(): "
+                        "Secure World POWER_MODE_PANIC!\n");
+                return -EINVAL;
+
+        default:
+                dprintk(KERN_ERR "tf_pm_resume(): "
+                        "unexpected Secure World POWER_MODE (%d)!\n", status);
+                return -EINVAL;
+        }
+
+        dprintk(KERN_INFO "tf_pm_resume() succeeded\n");
+        return 0;
+#endif
+}
+
+/*----------------------------------------------------------------------------
+ * Communication initialization and termination
+ *----------------------------------------------------------------------------*/
+
+/*
+ * Handles the software interrupts issued by the Secure World.
+ */
+static irqreturn_t tf_soft_int_handler(int irq, void *dev_id)
+{
+        struct tf_comm *comm = (struct tf_comm *) dev_id;
+
+        if (comm->l1_buffer == NULL)
+                return IRQ_NONE;
+
+        if ((tf_read_reg32(&comm->l1_buffer->status_s) &
+                        TF_STATUS_P_MASK) == 0)
+                /* interrupt not issued by the Trusted Foundations Software */
+                return IRQ_NONE;
+
+        tf_smc_reset_irq();
+
+        /* signal N_SM_EVENT */
+        wake_up(&comm->wait_queue);
+
+        return IRQ_HANDLED;
+}
+
+/*
+ * Initializes the communication with the Secure World.
+ * The L1 shared buffer is allocated and the Secure World
+ * is yielded for the first time.
+ * returns successfuly once the communication with
+ * the Secure World is up and running
+ *
+ * Returns 0 upon success or appropriate error code
+ * upon failure
+ */
+int tf_init(struct tf_comm *comm)
+{
+        int error;
+        struct page *buffer_page;
+        u32 protocol_version;
+
+        dprintk(KERN_INFO "tf_init()\n");
+
+        spin_lock_init(&(comm->lock));
+        comm->flags = 0;
+        comm->l1_buffer = NULL;
+        init_waitqueue_head(&(comm->wait_queue));
+
+        /*
+         * Check the Secure World protocol version is the expected one.
+         */
+        tf_smc_get_protocol_version(&protocol_version);
+
+        if ((GET_PROTOCOL_MAJOR_VERSION(protocol_version))
+                        != TF_S_PROTOCOL_MAJOR_VERSION) {
+                printk(KERN_ERR "tf_init():"
+                        " Unsupported Secure World Major Version "
+                        "(0x%02X, expected 0x%02X)!\n",
+                        GET_PROTOCOL_MAJOR_VERSION(protocol_version),
+                        TF_S_PROTOCOL_MAJOR_VERSION);
+                error = -EIO;
+                goto error;
+        }
+
+        /*
+         * Register the software interrupt handler if required to.
+         */
+        if (comm->soft_int_irq != -1) {
+                dprintk(KERN_INFO "tf_init(): "
+                        "Registering software interrupt handler (IRQ %d)\n",
+                        comm->soft_int_irq);
+
+                error = request_irq(comm->soft_int_irq,
+                        tf_soft_int_handler,
+                        IRQF_SHARED,
+                        TF_DEVICE_BASE_NAME,
+                        comm);
+                if (error != 0) {
+                        dprintk(KERN_ERR "tf_init(): "
+                                "request_irq failed for irq %d (error %d)\n",
+                        comm->soft_int_irq, error);
+                        goto error;
+                }
+                set_bit(TF_COMM_FLAG_IRQ_REQUESTED, &(comm->flags));
+        }
+
+        /*
+         * Allocate and initialize the L1 shared buffer.
+         */
+        comm->l1_buffer = (void *) internal_get_zeroed_page(GFP_KERNEL);
+        if (comm->l1_buffer == NULL) {
+                printk(KERN_ERR "tf_init():"
+                        " get_zeroed_page failed for L1 shared buffer!\n");
+                error = -ENOMEM;
+                goto error;
+        }
+
+        /*
+         * Ensure the page storing the L1 shared buffer is mapped.
+         */
+        buffer_page = virt_to_page(comm->l1_buffer);
+        trylock_page(buffer_page);
+
+        dprintk(KERN_INFO "tf_init(): "
+                "L1 shared buffer allocated at virtual:%p, "
+                "physical:%p (page:%p)\n",
+                comm->l1_buffer,
+                (void *)virt_to_phys(comm->l1_buffer),
+                buffer_page);
+
+        set_bit(TF_COMM_FLAG_L1_SHARED_ALLOCATED, &(comm->flags));
+
+        /*
+         * Init SMC
+         */
+        error = tf_smc_init(
+                tf_get_l2init_descriptor((u32)comm->l1_buffer));
+        if (error != S_SUCCESS) {
+                dprintk(KERN_ERR "tf_init(): "
+                        "tf_smc_init failed (error 0x%08X)!\n",
+                        error);
+                goto error;
+        }
+
+        /*
+         * check whether the interrupts are actually enabled
+         * If not, remove irq handler
+         */
+        if ((tf_read_reg32(&comm->l1_buffer->config_flag_s) &
+                        TF_CONFIG_FLAG_S) == 0) {
+                if (test_and_clear_bit(TF_COMM_FLAG_IRQ_REQUESTED,
+                                &(comm->flags)) != 0) {
+                        dprintk(KERN_INFO "tf_init(): "
+                                "Interrupts not used, unregistering "
+                                "softint (IRQ %d)\n",
+                                comm->soft_int_irq);
+
+                        free_irq(comm->soft_int_irq, comm);
+                }
+        } else {
+                if (test_bit(TF_COMM_FLAG_IRQ_REQUESTED,
+                                &(comm->flags)) == 0) {
+                        /*
+                         * Interrupts are enabled in the Secure World, but not
+                         * handled by driver
+                         */
+                        dprintk(KERN_ERR "tf_init(): "
+                                "soft_interrupt argument not provided\n");
+                        error = -EINVAL;
+                        goto error;
+                }
+        }
+
+        /*
+         * Successful completion.
+         */
+
+        /* yield for the first time */
+        (void)tf_schedule_secure_world(comm);
+
+        dprintk(KERN_INFO "tf_init(): Success\n");
+        return S_SUCCESS;
+
+error:
+        /*
+         * Error handling.
+         */
+        dprintk(KERN_INFO "tf_init(): Failure (error %d)\n",
+                error);
+        tf_terminate(comm);
+        return error;
+}
+
+
+/*
+ * Attempt to terminate the communication with the Secure World.
+ * The L1 shared buffer is freed.
+ * Calling this routine terminates definitaly the communication
+ * with the Secure World : there is no way to inform the Secure World of a new
+ * L1 shared buffer to be used once it has been initialized.
+ */
+void tf_terminate(struct tf_comm *comm)
+{
+        dprintk(KERN_INFO "tf_terminate()\n");
+
+        set_bit(TF_COMM_FLAG_TERMINATING, &(comm->flags));
+
+        if ((test_bit(TF_COMM_FLAG_W3B_ALLOCATED,
+                        &(comm->flags))) != 0) {
+                dprintk(KERN_INFO "tf_terminate(): "
+                        "Freeing the W3B buffer...\n");
+                tf_free_w3b(comm);
+        }
+
+        if ((test_bit(TF_COMM_FLAG_L1_SHARED_ALLOCATED,
+                        &(comm->flags))) != 0) {
+                __clear_page_locked(virt_to_page(comm->l1_buffer));
+                internal_free_page((unsigned long) comm->l1_buffer);
+        }
+
+        if ((test_bit(TF_COMM_FLAG_IRQ_REQUESTED,
+                        &(comm->flags))) != 0) {
+                dprintk(KERN_INFO "tf_terminate(): "
+                        "Unregistering softint (IRQ %d)\n",
+                        comm->soft_int_irq);
+                free_irq(comm->soft_int_irq, comm);
+        }
+}
diff --git a/security/tf_driver/tf_conn.c b/security/tf_driver/tf_conn.c
new file mode 100644
index 00000000000..3148fec4635
--- /dev/null
+++ b/security/tf_driver/tf_conn.c
@@ -0,0 +1,1574 @@
+/**
+ * Copyright (c) 2011 Trusted Logic S.A.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#include <linux/atomic.h>
+#include <linux/uaccess.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/list.h>
+#include <linux/mm.h>
+#include <linux/pagemap.h>
+#include <linux/stddef.h>
+#include <linux/types.h>
+
+#include "s_version.h"
+
+#include "tf_protocol.h"
+#include "tf_defs.h"
+#include "tf_util.h"
+#include "tf_comm.h"
+#include "tf_conn.h"
+
+#ifdef CONFIG_TF_ZEBRA
+#include "tf_crypto.h"
+#endif
+
+#ifdef CONFIG_ANDROID
+#define TF_PRIVILEGED_UID_GID 1000 /* Android system AID */
+#else
+#define TF_PRIVILEGED_UID_GID 0
+#endif
+
+/*----------------------------------------------------------------------------
+ * Management of the shared memory blocks.
+ *
+ * Shared memory blocks are the blocks registered through
+ * the commands REGISTER_SHARED_MEMORY and POWER_MANAGEMENT
+ *----------------------------------------------------------------------------*/
+
+/**
+ * Unmaps a shared memory
+ **/
+void tf_unmap_shmem(
+                struct tf_connection *connection,
+                struct tf_shmem_desc *shmem_desc,
+                u32 full_cleanup)
+{
+        /* check shmem_desc contains a descriptor */
+        if (shmem_desc == NULL)
+                return;
+
+        dprintk(KERN_DEBUG "tf_unmap_shmem(%p)\n", shmem_desc);
+
+retry:
+        mutex_lock(&(connection->shmem_mutex));
+        if (atomic_read(&shmem_desc->ref_count) > 1) {
+                /*
+                 * Shared mem still in use, wait for other operations completion
+                 * before actually unmapping it.
+                 */
+                dprintk(KERN_INFO "Descriptor in use\n");
+                mutex_unlock(&(connection->shmem_mutex));
+                schedule();
+                goto retry;
+        }
+
+        tf_cleanup_shared_memory(
+                        &(connection->cpt_alloc_context),
+                        shmem_desc,
+                        full_cleanup);
+
+        list_del(&(shmem_desc->list));
+
+        if ((shmem_desc->type == TF_SHMEM_TYPE_REGISTERED_SHMEM) ||
+                        (full_cleanup != 0)) {
+                internal_kfree(shmem_desc);
+
+                atomic_dec(&(connection->shmem_count));
+        } else {
+                /*
+                 * This is a preallocated shared memory, add to free list
+                 * Since the device context is unmapped last, it is
+                 * always the first element of the free list if no
+                 * device context has been created
+                 */
+                shmem_desc->block_identifier = 0;
+                list_add(&(shmem_desc->list), &(connection->free_shmem_list));
+        }
+
+        mutex_unlock(&(connection->shmem_mutex));
+}
+
+
+/**
+ * Find the first available slot for a new block of shared memory
+ * and map the user buffer.
+ * Update the descriptors to L1 descriptors
+ * Update the buffer_start_offset and buffer_size fields
+ * shmem_desc is updated to the mapped shared memory descriptor
+ **/
+int tf_map_shmem(
+                struct tf_connection *connection,
+                u32 buffer,
+                /* flags for read-write access rights on the memory */
+                u32 flags,
+                bool in_user_space,
+                u32 descriptors[TF_MAX_COARSE_PAGES],
+                u32 *buffer_start_offset,
+                u32 buffer_size,
+                struct tf_shmem_desc **shmem_desc,
+                u32 *descriptor_count)
+{
+        struct tf_shmem_desc *desc = NULL;
+        int error;
+
+        dprintk(KERN_INFO "tf_map_shmem(%p, %p, flags = 0x%08x)\n",
+                                        connection,
+                                        (void *) buffer,
+                                        flags);
+
+        mutex_lock(&(connection->shmem_mutex));
+
+        /*
+         * Check the list of free shared memory
+         * is not empty
+         */
+        if (list_empty(&(connection->free_shmem_list))) {
+                if (atomic_read(&(connection->shmem_count)) ==
+                                TF_SHMEM_MAX_COUNT) {
+                        printk(KERN_ERR "tf_map_shmem(%p):"
+                                " maximum shared memories already registered\n",
+                                connection);
+                        error = -ENOMEM;
+                        goto error;
+                }
+
+                /* no descriptor available, allocate a new one */
+
+                desc = (struct tf_shmem_desc *) internal_kmalloc(
+                        sizeof(*desc), GFP_KERNEL);
+                if (desc == NULL) {
+                        printk(KERN_ERR "tf_map_shmem(%p):"
+                                " failed to allocate descriptor\n",
+                                connection);
+                        error = -ENOMEM;
+                        goto error;
+                }
+
+                /* Initialize the structure */
+                desc->type = TF_SHMEM_TYPE_REGISTERED_SHMEM;
+                atomic_set(&desc->ref_count, 1);
+                INIT_LIST_HEAD(&(desc->list));
+
+                atomic_inc(&(connection->shmem_count));
+        } else {
+                /* take the first free shared memory descriptor */
+                desc = list_first_entry(&(connection->free_shmem_list),
+                        struct tf_shmem_desc, list);
+                list_del(&(desc->list));
+        }
+
+        /* Add the descriptor to the used list */
+        list_add(&(desc->list), &(connection->used_shmem_list));
+
+        error = tf_fill_descriptor_table(
+                        &(connection->cpt_alloc_context),
+                        desc,
+                        buffer,
+                        connection->vmas,
+                        descriptors,
+                        buffer_size,
+                        buffer_start_offset,
+                        in_user_space,
+                        flags,
+                        descriptor_count);
+
+        if (error != 0) {
+                dprintk(KERN_ERR "tf_map_shmem(%p):"
+                        " tf_fill_descriptor_table failed with error "
+                        "code %d!\n",
+                        connection,
+                        error);
+                goto error;
+        }
+        desc->client_buffer = (u8 *) buffer;
+
+        /*
+         * Successful completion.
+         */
+        *shmem_desc = desc;
+        mutex_unlock(&(connection->shmem_mutex));
+        dprintk(KERN_DEBUG "tf_map_shmem: success\n");
+        return 0;
+
+
+        /*
+         * Error handling.
+         */
+error:
+        mutex_unlock(&(connection->shmem_mutex));
+        dprintk(KERN_ERR "tf_map_shmem: failure with error code %d\n",
+                error);
+
+        tf_unmap_shmem(
+                        connection,
+                        desc,
+                        0);
+
+        return error;
+}
+
+
+
+/* This function is a copy of the find_vma() function
+in linux kernel 2.6.15 version with some fixes :
+        - memory block may end on vm_end
+        - check the full memory block is in the memory area
+        - guarantee NULL is returned if no memory area is found */
+struct vm_area_struct *tf_find_vma(struct mm_struct *mm,
+        unsigned long addr, unsigned long size)
+{
+        struct vm_area_struct *vma = NULL;
+
+        dprintk(KERN_INFO
+                "tf_find_vma addr=0x%lX size=0x%lX\n", addr, size);
+
+        if (mm) {
+                /* Check the cache first. */
+                /* (Cache hit rate is typically around 35%.) */
+                vma = mm->mmap_cache;
+                if (!(vma && vma->vm_end >= (addr+size) &&
+                                vma->vm_start <= addr)) {
+                        struct rb_node *rb_node;
+
+                        rb_node = mm->mm_rb.rb_node;
+                        vma = NULL;
+
+                        while (rb_node) {
+                                struct vm_area_struct *vma_tmp;
+
+                                vma_tmp = rb_entry(rb_node,
+                                        struct vm_area_struct, vm_rb);
+
+                                dprintk(KERN_INFO
+                                        "vma_tmp->vm_start=0x%lX"
+                                        "vma_tmp->vm_end=0x%lX\n",
+                                        vma_tmp->vm_start,
+                                        vma_tmp->vm_end);
+
+                                if (vma_tmp->vm_end >= (addr+size)) {
+                                        vma = vma_tmp;
+                                        if (vma_tmp->vm_start <= addr)
+                                                break;
+
+                                        rb_node = rb_node->rb_left;
+                                } else {
+                                        rb_node = rb_node->rb_right;
+                                }
+                        }
+
+                        if (vma)
+                                mm->mmap_cache = vma;
+                        if (rb_node == NULL)
+                                vma = NULL;
+                }
+        }
+        return vma;
+}
+
+int tf_validate_shmem_and_flags(
+        u32 shmem,
+        u32 shmem_size,
+        u32 flags)
+{
+        struct vm_area_struct *vma;
+        u32 chunk;
+
+        if (shmem_size == 0)
+                /* This is always valid */
+                return 0;
+
+        if ((shmem + shmem_size) < shmem)
+                /* Overflow */
+                return -EINVAL;
+
+        down_read(&current->mm->mmap_sem);
+
+        /*
+         *  When looking for a memory address, split buffer into chunks of
+         *  size=PAGE_SIZE.
+         */
+        chunk = PAGE_SIZE - (shmem & (PAGE_SIZE-1));
+        if (chunk > shmem_size)
+                chunk = shmem_size;
+
+        do {
+                vma = tf_find_vma(current->mm, shmem, chunk);
+
+                if (vma == NULL) {
+                        dprintk(KERN_ERR "%s: area not found\n", __func__);
+                        goto error;
+                }
+
+                if (flags & TF_SHMEM_TYPE_READ)
+                        if (!(vma->vm_flags & VM_READ)) {
+                                dprintk(KERN_ERR "%s: no read permission\n",
+                                        __func__);
+                                goto error;
+                        }
+                if (flags & TF_SHMEM_TYPE_WRITE)
+                        if (!(vma->vm_flags & VM_WRITE)) {
+                                dprintk(KERN_ERR "%s: no write permission\n",
+                                        __func__);
+                                goto error;
+                        }
+
+                shmem_size -= chunk;
+                shmem += chunk;
+                chunk = (shmem_size <= PAGE_SIZE ?
+                                shmem_size : PAGE_SIZE);
+        } while (shmem_size != 0);
+
+        up_read(&current->mm->mmap_sem);
+        return 0;
+
+error:
+        up_read(&current->mm->mmap_sem);
+        return -EFAULT;
+}
+
+
+static int tf_map_temp_shmem(struct tf_connection *connection,
+         struct tf_command_param_temp_memref *temp_memref,
+         u32 param_type,
+         struct tf_shmem_desc **shmem_desc)
+{
+        u32 flags;
+        u32 error = S_SUCCESS;
+        bool in_user_space = connection->owner != TF_CONNECTION_OWNER_KERNEL;
+
+        dprintk(KERN_INFO "tf_map_temp_shmem(%p, "
+                "0x%08x[size=0x%08x], offset=0x%08x)\n",
+                connection,
+                temp_memref->descriptor,
+                temp_memref->size,
+                temp_memref->offset);
+
+        switch (param_type) {
+        case TF_PARAM_TYPE_MEMREF_TEMP_INPUT:
+                flags = TF_SHMEM_TYPE_READ;
+                break;
+        case TF_PARAM_TYPE_MEMREF_TEMP_OUTPUT:
+                flags = TF_SHMEM_TYPE_WRITE;
+                break;
+        case TF_PARAM_TYPE_MEMREF_TEMP_INOUT:
+                flags = TF_SHMEM_TYPE_WRITE | TF_SHMEM_TYPE_READ;
+                break;
+        default:
+                error = -EINVAL;
+                goto error;
+        }
+
+        if (temp_memref->descriptor == 0) {
+                /* NULL tmpref */
+                temp_memref->offset = 0;
+                *shmem_desc = NULL;
+        } else if ((temp_memref->descriptor != 0) &&
+                        (temp_memref->size == 0)) {
+                /* Empty tmpref */
+                temp_memref->offset = temp_memref->descriptor;
+                temp_memref->descriptor = 0;
+                temp_memref->size = 0;
+                *shmem_desc = NULL;
+        } else {
+                /* Map the temp shmem block */
+
+                u32 shared_mem_descriptors[TF_MAX_COARSE_PAGES];
+                u32 descriptor_count;
+
+                if (in_user_space) {
+                        error = tf_validate_shmem_and_flags(
+                                temp_memref->descriptor,
+                                temp_memref->size,
+                                flags);
+                        if (error != 0)
+                                goto error;
+                }
+
+                error = tf_map_shmem(
+                                connection,
+                                temp_memref->descriptor,
+                                flags,
+                                in_user_space,
+                                shared_mem_descriptors,
+                                &(temp_memref->offset),
+                                temp_memref->size,
+                                shmem_desc,
+                                &descriptor_count);
+                temp_memref->descriptor = shared_mem_descriptors[0];
+         }
+
+error:
+         return error;
+}
+
+/*
+ * Clean up a list of shared memory descriptors.
+ */
+static void tf_shared_memory_cleanup_list(
+                struct tf_connection *connection,
+                struct list_head *shmem_desc_list)
+{
+        while (!list_empty(shmem_desc_list)) {
+                struct tf_shmem_desc *shmem_desc;
+
+                shmem_desc = list_first_entry(shmem_desc_list,
+                        struct tf_shmem_desc, list);
+
+                tf_unmap_shmem(connection, shmem_desc, 1);
+        }
+}
+
+
+/*
+ * Clean up the shared memory information in the connection.
+ * Releases all allocated pages.
+ */
+static void tf_cleanup_shared_memories(struct tf_connection *connection)
+{
+        /* clean up the list of used and free descriptors.
+         * done outside the mutex, because tf_unmap_shmem already
+         * mutex()ed
+         */
+        tf_shared_memory_cleanup_list(connection,
+                &connection->used_shmem_list);
+        tf_shared_memory_cleanup_list(connection,
+                &connection->free_shmem_list);
+
+        mutex_lock(&(connection->shmem_mutex));
+
+        /* Free the Vmas page */
+        if (connection->vmas) {
+                internal_free_page((unsigned long) connection->vmas);
+                connection->vmas = NULL;
+        }
+
+        tf_release_coarse_page_table_allocator(
+                &(connection->cpt_alloc_context));
+
+        mutex_unlock(&(connection->shmem_mutex));
+}
+
+
+/*
+ * Initialize the shared memory in a connection.
+ * Allocates the minimum memory to be provided
+ * for shared memory management
+ */
+int tf_init_shared_memory(struct tf_connection *connection)
+{
+        int error;
+        int i;
+        int coarse_page_index;
+
+        /*
+         * We only need to initialize special elements and attempt to allocate
+         * the minimum shared memory descriptors we want to support
+         */
+
+        mutex_init(&(connection->shmem_mutex));
+        INIT_LIST_HEAD(&(connection->free_shmem_list));
+        INIT_LIST_HEAD(&(connection->used_shmem_list));
+        atomic_set(&(connection->shmem_count), 0);
+
+        tf_init_coarse_page_table_allocator(
+                &(connection->cpt_alloc_context));
+
+
+        /*
+         * Preallocate 3 pages to increase the chances that a connection
+         * succeeds in allocating shared mem
+         */
+        for (i = 0;
+             i < 3;
+             i++) {
+                struct tf_shmem_desc *shmem_desc =
+                        (struct tf_shmem_desc *) internal_kmalloc(
+                                sizeof(*shmem_desc), GFP_KERNEL);
+
+                if (shmem_desc == NULL) {
+                        printk(KERN_ERR "tf_init_shared_memory(%p):"
+                                " failed to pre allocate descriptor %d\n",
+                                connection,
+                                i);
+                        error = -ENOMEM;
+                        goto error;
+                }
+
+                for (coarse_page_index = 0;
+                     coarse_page_index < TF_MAX_COARSE_PAGES;
+                     coarse_page_index++) {
+                        struct tf_coarse_page_table *coarse_pg_table;
+
+                        coarse_pg_table = tf_alloc_coarse_page_table(
+                                &(connection->cpt_alloc_context),
+                                TF_PAGE_DESCRIPTOR_TYPE_PREALLOCATED);
+
+                        if (coarse_pg_table == NULL) {
+                                printk(KERN_ERR "tf_init_shared_memory(%p)"
+                                        ": descriptor %d coarse page %d - "
+                                        "tf_alloc_coarse_page_table() "
+                                        "failed\n",
+                                        connection,
+                                        i,
+                                        coarse_page_index);
+                                error = -ENOMEM;
+                                goto error;
+                        }
+
+                        shmem_desc->coarse_pg_table[coarse_page_index] =
+                                coarse_pg_table;
+                }
+                shmem_desc->coarse_pg_table_count = 0;
+
+                shmem_desc->type = TF_SHMEM_TYPE_PREALLOC_REGISTERED_SHMEM;
+                atomic_set(&shmem_desc->ref_count, 1);
+
+                /*
+                 * add this preallocated descriptor to the list of free
+                 * descriptors Keep the device context specific one at the
+                 * beginning of the list
+                 */
+                INIT_LIST_HEAD(&(shmem_desc->list));
+                list_add_tail(&(shmem_desc->list),
+                        &(connection->free_shmem_list));
+        }
+
+        /* allocate memory for the vmas structure */
+        connection->vmas =
+                (struct vm_area_struct **) internal_get_zeroed_page(GFP_KERNEL);
+        if (connection->vmas == NULL) {
+                printk(KERN_ERR "tf_init_shared_memory(%p):"
+                        " vmas - failed to get_zeroed_page\n",
+                        connection);
+                error = -ENOMEM;
+                goto error;
+        }
+
+        return 0;
+
+error:
+        tf_cleanup_shared_memories(connection);
+        return error;
+}
+
+/*----------------------------------------------------------------------------
+ * Connection operations to the Secure World
+ *----------------------------------------------------------------------------*/
+
+int tf_create_device_context(
+        struct tf_connection *connection)
+{
+        union tf_command command;
+        union tf_answer  answer;
+        int error = 0;
+
+        dprintk(KERN_INFO "tf_create_device_context(%p)\n",
+                        connection);
+
+        command.create_device_context.message_type =
+                TF_MESSAGE_TYPE_CREATE_DEVICE_CONTEXT;
+        command.create_device_context.message_size =
+                (sizeof(struct tf_command_create_device_context)
+                        - sizeof(struct tf_command_header))/sizeof(u32);
+        command.create_device_context.operation_id = (u32) &answer;
+        command.create_device_context.device_context_id = (u32) connection;
+
+        error = tf_send_receive(
+                &connection->dev->sm,
+                &command,
+                &answer,
+                connection,
+                true);
+
+        if ((error != 0) ||
+                (answer.create_device_context.error_code != S_SUCCESS))
+                goto error;
+
+        /*
+         * CREATE_DEVICE_CONTEXT succeeded,
+         * store device context handler and update connection status
+         */
+        connection->device_context =
+                answer.create_device_context.device_context;
+        spin_lock(&(connection->state_lock));
+        connection->state = TF_CONN_STATE_VALID_DEVICE_CONTEXT;
+        spin_unlock(&(connection->state_lock));
+
+        /* successful completion */
+        dprintk(KERN_INFO "tf_create_device_context(%p):"
+                " device_context=0x%08x\n",
+                connection,
+                answer.create_device_context.device_context);
+        return 0;
+
+error:
+        if (error != 0) {
+                dprintk(KERN_ERR "tf_create_device_context failed with "
+                        "error %d\n", error);
+        } else {
+                /*
+                 * We sent a DeviceCreateContext. The state is now
+                 * TF_CONN_STATE_CREATE_DEVICE_CONTEXT_SENT It has to be
+                 * reset if we ever want to send a DeviceCreateContext again
+                 */
+                spin_lock(&(connection->state_lock));
+                connection->state = TF_CONN_STATE_NO_DEVICE_CONTEXT;
+                spin_unlock(&(connection->state_lock));
+                dprintk(KERN_ERR "tf_create_device_context failed with "
+                        "error_code 0x%08X\n",
+                        answer.create_device_context.error_code);
+                if (answer.create_device_context.error_code ==
+                        S_ERROR_OUT_OF_MEMORY)
+                        error = -ENOMEM;
+                else
+                        error = -EFAULT;
+        }
+
+        return error;
+}
+
+/* Check that the current application belongs to the
+ * requested GID */
+static bool tf_check_gid(gid_t requested_gid)
+{
+        if (requested_gid == current_egid()) {
+                return true;
+        } else {
+                u32    size;
+                u32    i;
+                /* Look in the supplementary GIDs */
+                get_group_info(GROUP_INFO);
+                size = GROUP_INFO->ngroups;
+                for (i = 0; i < size; i++)
+                        if (requested_gid == GROUP_AT(GROUP_INFO , i))
+                                return true;
+        }
+        return false;
+}
+
+/*
+ * Opens a client session to the Secure World
+ */
+int tf_open_client_session(
+        struct tf_connection *connection,
+        union tf_command *command,
+        union tf_answer *answer)
+{
+        int error = 0;
+        struct tf_shmem_desc *shmem_desc[4] = {NULL};
+        u32 i;
+
+        dprintk(KERN_INFO "tf_open_client_session(%p)\n", connection);
+
+        /*
+         * Initialize the message size with no login data. This will be later
+         * adjusted the the cases below
+         */
+        command->open_client_session.message_size =
+                (sizeof(struct tf_command_open_client_session) - 20
+                        - sizeof(struct tf_command_header))/4;
+
+        switch (command->open_client_session.login_type) {
+        case TF_LOGIN_PUBLIC:
+                 /* Nothing to do */
+                 break;
+
+        case TF_LOGIN_USER:
+                /*
+                 * Send the EUID of the calling application in the login data.
+                 * Update message size.
+                 */
+                *(u32 *) &command->open_client_session.login_data =
+                        current_euid();
+#ifndef CONFIG_ANDROID
+                command->open_client_session.login_type =
+                        (u32) TF_LOGIN_USER_LINUX_EUID;
+#else
+                command->open_client_session.login_type =
+                        (u32) TF_LOGIN_USER_ANDROID_EUID;
+#endif
+
+                /* Added one word */
+                command->open_client_session.message_size += 1;
+                break;
+
+        case TF_LOGIN_GROUP: {
+                /* Check requested GID */
+                gid_t  requested_gid =
+                        *(u32 *) command->open_client_session.login_data;
+
+                if (!tf_check_gid(requested_gid)) {
+                        dprintk(KERN_ERR "tf_open_client_session(%p) "
+                                "TF_LOGIN_GROUP: requested GID (0x%x) does "
+                                "not match real eGID (0x%x)"
+                                "or any of the supplementary GIDs\n",
+                                connection, requested_gid, current_egid());
+                        error = -EACCES;
+                        goto error;
+                }
+#ifndef CONFIG_ANDROID
+                command->open_client_session.login_type =
+                        TF_LOGIN_GROUP_LINUX_GID;
+#else
+                command->open_client_session.login_type =
+                        TF_LOGIN_GROUP_ANDROID_GID;
+#endif
+
+                command->open_client_session.message_size += 1; /* GID */
+                break;
+        }
+
+#ifndef CONFIG_ANDROID
+        case TF_LOGIN_APPLICATION: {
+                /*
+                 * Compute SHA-1 hash of the application fully-qualified path
+                 * name.  Truncate the hash to 16 bytes and send it as login
+                 * data.  Update message size.
+                 */
+                u8 pSHA1Hash[SHA1_DIGEST_SIZE];
+
+                error = tf_hash_application_path_and_data(pSHA1Hash,
+                        NULL, 0);
+                if (error != 0) {
+                        dprintk(KERN_ERR "tf_open_client_session: "
+                                "error in tf_hash_application_path_and_data\n");
+                        goto error;
+                }
+                memcpy(&command->open_client_session.login_data,
+                        pSHA1Hash, 16);
+                command->open_client_session.login_type =
+                        TF_LOGIN_APPLICATION_LINUX_PATH_SHA1_HASH;
+                /* 16 bytes */
+                command->open_client_session.message_size += 4;
+                break;
+        }
+#else
+        case TF_LOGIN_APPLICATION:
+                /*
+                 * Send the real UID of the calling application in the login
+                 * data. Update message size.
+                 */
+                *(u32 *) &command->open_client_session.login_data =
+                        current_uid();
+
+                command->open_client_session.login_type =
+                        (u32) TF_LOGIN_APPLICATION_ANDROID_UID;
+
+                /* Added one word */
+                command->open_client_session.message_size += 1;
+                break;
+#endif
+
+#ifndef CONFIG_ANDROID
+        case TF_LOGIN_APPLICATION_USER: {
+                /*
+                 * Compute SHA-1 hash of the concatenation of the application
+                 * fully-qualified path name and the EUID of the calling
+                 * application.  Truncate the hash to 16 bytes and send it as
+                 * login data.  Update message size.
+                 */
+                u8 pSHA1Hash[SHA1_DIGEST_SIZE];
+
+                error = tf_hash_application_path_and_data(pSHA1Hash,
+                        (u8 *) &(current_euid()), sizeof(current_euid()));
+                if (error != 0) {
+                        dprintk(KERN_ERR "tf_open_client_session: "
+                                "error in tf_hash_application_path_and_data\n");
+                        goto error;
+                }
+                memcpy(&command->open_client_session.login_data,
+                        pSHA1Hash, 16);
+                command->open_client_session.login_type =
+                        TF_LOGIN_APPLICATION_USER_LINUX_PATH_EUID_SHA1_HASH;
+
+                /* 16 bytes */
+                command->open_client_session.message_size += 4;
+
+                break;
+        }
+#else
+        case TF_LOGIN_APPLICATION_USER:
+                /*
+                 * Send the real UID and the EUID of the calling application in
+                 * the login data. Update message size.
+                 */
+                *(u32 *) &command->open_client_session.login_data =
+                        current_uid();
+                *(u32 *) &command->open_client_session.login_data[4] =
+                        current_euid();
+
+                command->open_client_session.login_type =
+                        TF_LOGIN_APPLICATION_USER_ANDROID_UID_EUID;
+
+                /* Added two words */
+                command->open_client_session.message_size += 2;
+                break;
+#endif
+
+#ifndef CONFIG_ANDROID
+        case TF_LOGIN_APPLICATION_GROUP: {
+                /*
+                 * Check requested GID.  Compute SHA-1 hash of the concatenation
+                 * of the application fully-qualified path name and the
+                 * requested GID.  Update message size
+                 */
+                gid_t  requested_gid;
+                u8     pSHA1Hash[SHA1_DIGEST_SIZE];
+
+                requested_gid = *(u32 *) &command->open_client_session.
+                        login_data;
+
+                if (!tf_check_gid(requested_gid)) {
+                        dprintk(KERN_ERR "tf_open_client_session(%p) "
+                        "TF_LOGIN_APPLICATION_GROUP: requested GID (0x%x) "
+                        "does not match real eGID (0x%x)"
+                        "or any of the supplementary GIDs\n",
+                        connection, requested_gid, current_egid());
+                        error = -EACCES;
+                        goto error;
+                }
+
+                error = tf_hash_application_path_and_data(pSHA1Hash,
+                        &requested_gid, sizeof(u32));
+                if (error != 0) {
+                        dprintk(KERN_ERR "tf_open_client_session: "
+                                "error in tf_hash_application_path_and_data\n");
+                        goto error;
+                }
+
+                memcpy(&command->open_client_session.login_data,
+                        pSHA1Hash, 16);
+                command->open_client_session.login_type =
+                        TF_LOGIN_APPLICATION_GROUP_LINUX_PATH_GID_SHA1_HASH;
+
+                /* 16 bytes */
+                command->open_client_session.message_size += 4;
+                break;
+        }
+#else
+        case TF_LOGIN_APPLICATION_GROUP: {
+                /*
+                 * Check requested GID. Send the real UID and the requested GID
+                 * in the login data. Update message size.
+                 */
+                gid_t requested_gid;
+
+                requested_gid = *(u32 *) &command->open_client_session.
+                        login_data;
+
+                if (!tf_check_gid(requested_gid)) {
+                        dprintk(KERN_ERR "tf_open_client_session(%p) "
+                        "TF_LOGIN_APPLICATION_GROUP: requested GID (0x%x) "
+                        "does not match real eGID (0x%x)"
+                        "or any of the supplementary GIDs\n",
+                        connection, requested_gid, current_egid());
+                        error = -EACCES;
+                        goto error;
+                }
+
+                *(u32 *) &command->open_client_session.login_data =
+                        current_uid();
+                *(u32 *) &command->open_client_session.login_data[4] =
+                        requested_gid;
+
+                command->open_client_session.login_type =
+                        TF_LOGIN_APPLICATION_GROUP_ANDROID_UID_GID;
+
+                /* Added two words */
+                command->open_client_session.message_size += 2;
+
+                break;
+        }
+#endif
+
+        case TF_LOGIN_PRIVILEGED:
+                /* A privileged login may be performed only on behalf of the
+                   kernel itself or on behalf of a process with euid=0 or
+                   egid=0 or euid=system or egid=system. */
+                if (connection->owner == TF_CONNECTION_OWNER_KERNEL) {
+                        dprintk(KERN_DEBUG "tf_open_client_session: "
+                                "TF_LOGIN_PRIVILEGED for kernel API\n");
+                } else if ((current_euid() != TF_PRIVILEGED_UID_GID) &&
+                           (current_egid() != TF_PRIVILEGED_UID_GID) &&
+                           (current_euid() != 0) && (current_egid() != 0)) {
+                        dprintk(KERN_ERR "tf_open_client_session: "
+                                " user %d, group %d not allowed to open "
+                                "session with TF_LOGIN_PRIVILEGED\n",
+                                current_euid(), current_egid());
+                        error = -EACCES;
+                        goto error;
+                } else {
+                        dprintk(KERN_DEBUG "tf_open_client_session: "
+                                "TF_LOGIN_PRIVILEGED for %u:%u\n",
+                                current_euid(), current_egid());
+                }
+                command->open_client_session.login_type =
+                        TF_LOGIN_PRIVILEGED;
+                break;
+
+        case TF_LOGIN_AUTHENTICATION: {
+                /*
+                 * Compute SHA-1 hash of the application binary
+                 * Send this hash as the login data (20 bytes)
+                 */
+
+                u8 *hash;
+                hash = &(command->open_client_session.login_data[0]);
+
+                error = tf_get_current_process_hash(hash);
+                if (error != 0) {
+                        dprintk(KERN_ERR "tf_open_client_session: "
+                                "error in tf_get_current_process_hash\n");
+                        goto error;
+                }
+                command->open_client_session.login_type =
+                        TF_LOGIN_AUTHENTICATION_BINARY_SHA1_HASH;
+
+                /* 20 bytes */
+                command->open_client_session.message_size += 5;
+                break;
+        }
+
+        case TF_LOGIN_PRIVILEGED_KERNEL:
+                /* A kernel login may be performed only on behalf of the
+                   kernel itself. */
+                if (connection->owner == TF_CONNECTION_OWNER_KERNEL) {
+                        dprintk(KERN_DEBUG "tf_open_client_session: "
+                                "TF_LOGIN_PRIVILEGED_KERNEL for kernel API\n");
+                        command->open_client_session.login_type =
+                                TF_LOGIN_PRIVILEGED_KERNEL;
+                } else {
+                        dprintk(KERN_ERR "tf_open_client_session: "
+                                " user %d, group %d not allowed to open "
+                                "session with TF_LOGIN_PRIVILEGED_KERNEL\n",
+                                current_euid(), current_egid());
+                        error = -EACCES;
+                        goto error;
+                }
+                command->open_client_session.login_type =
+                        TF_LOGIN_PRIVILEGED_KERNEL;
+                break;
+
+        default:
+                 dprintk(KERN_ERR "tf_open_client_session: "
+                        "unknown login_type(%08X)\n",
+                        command->open_client_session.login_type);
+                 error = -EOPNOTSUPP;
+                 goto error;
+        }
+
+        /* Map the temporary memory references */
+        for (i = 0; i < 4; i++) {
+                int param_type;
+                param_type = TF_GET_PARAM_TYPE(
+                        command->open_client_session.param_types, i);
+                if ((param_type & (TF_PARAM_TYPE_MEMREF_FLAG |
+                                   TF_PARAM_TYPE_REGISTERED_MEMREF_FLAG))
+                                == TF_PARAM_TYPE_MEMREF_FLAG) {
+                        /* Map temp mem ref */
+                        error = tf_map_temp_shmem(connection,
+                                &command->open_client_session.
+                                        params[i].temp_memref,
+                                param_type,
+                                &shmem_desc[i]);
+                        if (error != 0) {
+                                dprintk(KERN_ERR "tf_open_client_session: "
+                                        "unable to map temporary memory block "
+                                        "(%08X)\n", error);
+                                goto error;
+                        }
+                }
+        }
+
+        /* Fill the handle of the Device Context */
+        command->open_client_session.device_context =
+                connection->device_context;
+
+        error = tf_send_receive(
+                &connection->dev->sm,
+                command,
+                answer,
+                connection,
+                true);
+
+error:
+        /* Unmap the temporary memory references */
+        for (i = 0; i < 4; i++)
+                if (shmem_desc[i] != NULL)
+                        tf_unmap_shmem(connection, shmem_desc[i], 0);
+
+        if (error != 0)
+                dprintk(KERN_ERR "tf_open_client_session returns %d\n",
+                        error);
+        else
+                dprintk(KERN_ERR "tf_open_client_session returns "
+                        "error_code 0x%08X\n",
+                        answer->open_client_session.error_code);
+
+        return error;
+}
+
+
+/*
+ * Closes a client session from the Secure World
+ */
+int tf_close_client_session(
+        struct tf_connection *connection,
+        union tf_command *command,
+        union tf_answer *answer)
+{
+        int error = 0;
+
+        dprintk(KERN_DEBUG "tf_close_client_session(%p)\n", connection);
+
+        command->close_client_session.message_size =
+                (sizeof(struct tf_command_close_client_session) -
+                        sizeof(struct tf_command_header)) / 4;
+        command->close_client_session.device_context =
+                connection->device_context;
+
+        error = tf_send_receive(
+                &connection->dev->sm,
+                command,
+                answer,
+                connection,
+                true);
+
+        if (error != 0)
+                dprintk(KERN_ERR "tf_close_client_session returns %d\n",
+                        error);
+        else
+                dprintk(KERN_ERR "tf_close_client_session returns "
+                        "error 0x%08X\n",
+                        answer->close_client_session.error_code);
+
+        return error;
+}
+
+
+/*
+ * Registers a shared memory to the Secure World
+ */
+int tf_register_shared_memory(
+        struct tf_connection *connection,
+        union tf_command *command,
+        union tf_answer *answer)
+{
+        int error = 0;
+        struct tf_shmem_desc *shmem_desc = NULL;
+        bool in_user_space = connection->owner != TF_CONNECTION_OWNER_KERNEL;
+        struct tf_command_register_shared_memory *msg =
+                &command->register_shared_memory;
+
+        dprintk(KERN_INFO "tf_register_shared_memory(%p) "
+                "%p[0x%08X][0x%08x]\n",
+                connection,
+                (void *)msg->shared_mem_descriptors[0],
+                msg->shared_mem_size,
+                (u32)msg->memory_flags);
+
+        if (in_user_space) {
+                error = tf_validate_shmem_and_flags(
+                        msg->shared_mem_descriptors[0],
+                        msg->shared_mem_size,
+                        (u32)msg->memory_flags);
+                if (error != 0)
+                        goto error;
+        }
+
+        /* Initialize message_size with no descriptors */
+        msg->message_size
+                = (offsetof(struct tf_command_register_shared_memory,
+                                                shared_mem_descriptors) -
+                        sizeof(struct tf_command_header)) / 4;
+
+        /* Map the shmem block and update the message */
+        if (msg->shared_mem_size == 0) {
+                /* Empty shared mem */
+                msg->shared_mem_start_offset = msg->shared_mem_descriptors[0];
+        } else {
+                u32 descriptor_count;
+                error = tf_map_shmem(
+                        connection,
+                        msg->shared_mem_descriptors[0],
+                        msg->memory_flags,
+                        in_user_space,
+                        msg->shared_mem_descriptors,
+                        &(msg->shared_mem_start_offset),
+                        msg->shared_mem_size,
+                        &shmem_desc,
+                        &descriptor_count);
+                if (error != 0) {
+                        dprintk(KERN_ERR "tf_register_shared_memory: "
+                                "unable to map shared memory block\n");
+                        goto error;
+                }
+                msg->message_size += descriptor_count;
+        }
+
+        /*
+         * write the correct device context handle and the address of the shared
+         * memory descriptor in the message
+         */
+        msg->device_context = connection->device_context;
+        msg->block_id = (u32)shmem_desc;
+
+        /* Send the updated message */
+        error = tf_send_receive(
+                &connection->dev->sm,
+                command,
+                answer,
+                connection,
+                true);
+
+        if ((error != 0) ||
+                (answer->register_shared_memory.error_code
+                        != S_SUCCESS)) {
+                dprintk(KERN_ERR "tf_register_shared_memory: "
+                        "operation failed. Unmap block\n");
+                goto error;
+        }
+
+        /* Saves the block handle returned by the secure world */
+        if (shmem_desc != NULL)
+                shmem_desc->block_identifier =
+                        answer->register_shared_memory.block;
+
+        /* successful completion */
+        dprintk(KERN_INFO "tf_register_shared_memory(%p):"
+                " block_id=0x%08x block=0x%08x\n",
+                connection, msg->block_id,
+                answer->register_shared_memory.block);
+        return 0;
+
+        /* error completion */
+error:
+        tf_unmap_shmem(
+                connection,
+                shmem_desc,
+                0);
+
+        if (error != 0)
+                dprintk(KERN_ERR "tf_register_shared_memory returns %d\n",
+                        error);
+        else
+                dprintk(KERN_ERR "tf_register_shared_memory returns "
+                        "error_code 0x%08X\n",
+                        answer->register_shared_memory.error_code);
+
+        return error;
+}
+
+
+/*
+ * Releases a shared memory from the Secure World
+ */
+int tf_release_shared_memory(
+        struct tf_connection *connection,
+        union tf_command *command,
+        union tf_answer *answer)
+{
+        int error = 0;
+
+        dprintk(KERN_DEBUG "tf_release_shared_memory(%p)\n", connection);
+
+        command->release_shared_memory.message_size =
+                (sizeof(struct tf_command_release_shared_memory) -
+                        sizeof(struct tf_command_header)) / 4;
+        command->release_shared_memory.device_context =
+                connection->device_context;
+
+        error = tf_send_receive(
+                &connection->dev->sm,
+                command,
+                answer,
+                connection,
+                true);
+
+        if ((error != 0) ||
+                (answer->release_shared_memory.error_code != S_SUCCESS))
+                goto error;
+
+        /* Use block_id to get back the pointer to shmem_desc */
+        tf_unmap_shmem(
+                connection,
+                (struct tf_shmem_desc *)
+                        answer->release_shared_memory.block_id,
+                0);
+
+        /* successful completion */
+        dprintk(KERN_INFO "tf_release_shared_memory(%p):"
+                " block_id=0x%08x block=0x%08x\n",
+                connection, answer->release_shared_memory.block_id,
+                command->release_shared_memory.block);
+        return 0;
+
+
+error:
+        if (error != 0)
+                dprintk(KERN_ERR "tf_release_shared_memory returns %d\n",
+                        error);
+        else
+                dprintk(KERN_ERR "tf_release_shared_memory returns "
+                        "nChannelStatus 0x%08X\n",
+                        answer->release_shared_memory.error_code);
+
+        return error;
+
+}
+
+
+/*
+ * Invokes a client command to the Secure World
+ */
+int tf_invoke_client_command(
+        struct tf_connection *connection,
+        union tf_command *command,
+        union tf_answer *answer)
+{
+        int error = 0;
+        struct tf_shmem_desc *shmem_desc[4] = {NULL};
+        int i;
+
+        dprintk(KERN_INFO "tf_invoke_client_command(%p)\n", connection);
+
+        command->release_shared_memory.message_size =
+                (sizeof(struct tf_command_invoke_client_command) -
+                        sizeof(struct tf_command_header)) / 4;
+
+#ifdef CONFIG_TF_ZEBRA
+        error = tf_crypto_try_shortcuted_update(connection,
+                (struct tf_command_invoke_client_command *) command,
+                (struct tf_answer_invoke_client_command *) answer);
+        if (error == 0)
+                return error;
+#endif
+
+        /* Map the tmprefs */
+        for (i = 0; i < 4; i++) {
+                int param_type = TF_GET_PARAM_TYPE(
+                        command->invoke_client_command.param_types, i);
+                if ((param_type & (TF_PARAM_TYPE_MEMREF_FLAG |
+                                   TF_PARAM_TYPE_REGISTERED_MEMREF_FLAG))
+                                == TF_PARAM_TYPE_MEMREF_FLAG) {
+                        /* A temporary memref: map it */
+                        error = tf_map_temp_shmem(connection,
+                                        &command->invoke_client_command.
+                                                params[i].temp_memref,
+                                        param_type, &shmem_desc[i]);
+                        if (error != 0) {
+                                dprintk(KERN_ERR
+                                        "tf_invoke_client_command: "
+                                        "unable to map temporary memory "
+                                        "block\n (%08X)", error);
+                                goto error;
+                        }
+                }
+        }
+
+        command->invoke_client_command.device_context =
+                connection->device_context;
+
+        error = tf_send_receive(&connection->dev->sm, command,
+                answer, connection, true);
+
+error:
+        /* Unmap de temp mem refs */
+        for (i = 0; i < 4; i++) {
+                if (shmem_desc[i] != NULL) {
+                        dprintk(KERN_INFO "tf_invoke_client_command: "
+                                "UnMatemp_memref %d\n ", i);
+                        tf_unmap_shmem(connection, shmem_desc[i], 0);
+                }
+        }
+
+        if (error != 0)
+                dprintk(KERN_ERR "tf_invoke_client_command returns %d\n",
+                        error);
+        else
+                dprintk(KERN_ERR "tf_invoke_client_command returns "
+                        "error_code 0x%08X\n",
+                        answer->invoke_client_command.error_code);
+
+        return error;
+}
+
+
+/*
+ * Cancels a client command from the Secure World
+ */
+int tf_cancel_client_command(
+        struct tf_connection *connection,
+        union tf_command *command,
+        union tf_answer *answer)
+{
+        int error = 0;
+
+        dprintk(KERN_DEBUG "tf_cancel_client_command(%p)\n", connection);
+
+        command->cancel_client_operation.device_context =
+                connection->device_context;
+        command->cancel_client_operation.message_size =
+                (sizeof(struct tf_command_cancel_client_operation) -
+                        sizeof(struct tf_command_header)) / 4;
+
+        error = tf_send_receive(
+                &connection->dev->sm,
+                command,
+                answer,
+                connection,
+                true);
+
+        if ((error != 0) ||
+                (answer->cancel_client_operation.error_code != S_SUCCESS))
+                goto error;
+
+
+        /* successful completion */
+        return 0;
+
+error:
+        if (error != 0)
+                dprintk(KERN_ERR "tf_cancel_client_command returns %d\n",
+                        error);
+        else
+                dprintk(KERN_ERR "tf_cancel_client_command returns "
+                        "nChannelStatus 0x%08X\n",
+                        answer->cancel_client_operation.error_code);
+
+        return error;
+}
+
+
+
+/*
+ * Destroys a device context from the Secure World
+ */
+int tf_destroy_device_context(
+        struct tf_connection *connection)
+{
+        int error;
+        /*
+         * AFY: better use the specialized tf_command_destroy_device_context
+         * structure: this will save stack
+         */
+        union tf_command command;
+        union tf_answer answer;
+
+        dprintk(KERN_INFO "tf_destroy_device_context(%p)\n", connection);
+
+        BUG_ON(connection == NULL);
+
+        command.header.message_type = TF_MESSAGE_TYPE_DESTROY_DEVICE_CONTEXT;
+        command.header.message_size =
+                (sizeof(struct tf_command_destroy_device_context) -
+                        sizeof(struct tf_command_header))/sizeof(u32);
+
+        /*
+         * fill in the device context handler
+         * it is guarantied that the first shared memory descriptor describes
+         * the device context
+         */
+        command.destroy_device_context.device_context =
+                connection->device_context;
+
+        error = tf_send_receive(
+                &connection->dev->sm,
+                &command,
+                &answer,
+                connection,
+                false);
+
+        if ((error != 0) ||
+                (answer.destroy_device_context.error_code != S_SUCCESS))
+                goto error;
+
+        spin_lock(&(connection->state_lock));
+        connection->state = TF_CONN_STATE_NO_DEVICE_CONTEXT;
+        spin_unlock(&(connection->state_lock));
+
+        /* successful completion */
+        dprintk(KERN_INFO "tf_destroy_device_context(%p)\n",
+                connection);
+        return 0;
+
+error:
+        if (error != 0) {
+                dprintk(KERN_ERR "tf_destroy_device_context failed with "
+                        "error %d\n", error);
+        } else {
+                dprintk(KERN_ERR "tf_destroy_device_context failed with "
+                        "error_code 0x%08X\n",
+                        answer.destroy_device_context.error_code);
+                if (answer.destroy_device_context.error_code ==
+                        S_ERROR_OUT_OF_MEMORY)
+                        error = -ENOMEM;
+                else
+                        error = -EFAULT;
+        }
+
+        return error;
+}
+
+
+/*----------------------------------------------------------------------------
+ * Connection initialization and cleanup operations
+ *----------------------------------------------------------------------------*/
+
+/*
+ * Opens a connection to the specified device.
+ *
+ * The placeholder referenced by connection is set to the address of the
+ * new connection; it is set to NULL upon failure.
+ *
+ * Returns zero upon successful completion, or an appropriate error code upon
+ * failure.
+ */
+int tf_open(struct tf_device *dev,
+        struct file *file,
+        struct tf_connection **connection)
+{
+        int error;
+        struct tf_connection *conn = NULL;
+
+        dprintk(KERN_INFO "tf_open(%p, %p)\n", file, connection);
+
+        /*
+         * Allocate and initialize the conn.
+         * kmalloc only allocates sizeof(*conn) virtual memory
+         */
+        conn = (struct tf_connection *) internal_kmalloc(sizeof(*conn),
+                GFP_KERNEL);
+        if (conn == NULL) {
+                printk(KERN_ERR "tf_open(): "
+                        "Out of memory for conn!\n");
+                error = -ENOMEM;
+                goto error;
+        }
+
+        memset(conn, 0, sizeof(*conn));
+
+        conn->state = TF_CONN_STATE_NO_DEVICE_CONTEXT;
+        conn->dev = dev;
+        spin_lock_init(&(conn->state_lock));
+        atomic_set(&(conn->pending_op_count), 0);
+        INIT_LIST_HEAD(&(conn->list));
+
+        /*
+         * Initialize the shared memory
+         */
+        error = tf_init_shared_memory(conn);
+        if (error != 0)
+                goto error;
+
+#ifdef CONFIG_TF_ZEBRA
+        /*
+         * Initialize CUS specifics
+         */
+        tf_crypto_init_cus(conn);
+#endif
+
+        /*
+         * Attach the conn to the device.
+         */
+        spin_lock(&(dev->connection_list_lock));
+        list_add(&(conn->list), &(dev->connection_list));
+        spin_unlock(&(dev->connection_list_lock));
+
+        /*
+         * Successful completion.
+         */
+
+        *connection = conn;
+
+        dprintk(KERN_INFO "tf_open(): Success (conn=%p)\n", conn);
+        return 0;
+
+        /*
+         * Error handling.
+         */
+
+error:
+        dprintk(KERN_ERR "tf_open(): Failure (error %d)\n", error);
+        /* Deallocate the descriptor pages if necessary */
+        internal_kfree(conn);
+        *connection = NULL;
+        return error;
+}
+
+
+/*
+ * Closes the specified connection.
+ *
+ * Upon return, the connection has been destroyed and cannot be used anymore.
+ *
+ * This function does nothing if connection is set to NULL.
+ */
+void tf_close(struct tf_connection *connection)
+{
+        int error;
+        enum TF_CONN_STATE state;
+
+        dprintk(KERN_DEBUG "tf_close(%p)\n", connection);
+
+        if (connection == NULL)
+                return;
+
+        /*
+         * Assumption: Linux guarantees that no other operation is in progress
+         * and that no other operation will be started when close is called
+         */
+        BUG_ON(atomic_read(&(connection->pending_op_count)) != 0);
+
+        /*
+         * Exchange a Destroy Device Context message if needed.
+         */
+        spin_lock(&(connection->state_lock));
+        state = connection->state;
+        spin_unlock(&(connection->state_lock));
+        if (state == TF_CONN_STATE_VALID_DEVICE_CONTEXT) {
+                /*
+                 * A DestroyDeviceContext operation was not performed. Do it
+                 * now.
+                 */
+                error = tf_destroy_device_context(connection);
+                if (error != 0)
+                        /* avoid cleanup if destroy device context fails */
+                        goto error;
+        }
+
+        /*
+         * Clean up the shared memory
+         */
+        tf_cleanup_shared_memories(connection);
+
+        spin_lock(&(connection->dev->connection_list_lock));
+        list_del(&(connection->list));
+        spin_unlock(&(connection->dev->connection_list_lock));
+
+        internal_kfree(connection);
+
+        return;
+
+error:
+        dprintk(KERN_DEBUG "tf_close(%p) failed with error code %d\n",
+                connection, error);
+}
+
diff --git a/security/tf_driver/tf_conn.h b/security/tf_driver/tf_conn.h
new file mode 100644
index 00000000000..8bed16f19d5
--- /dev/null
+++ b/security/tf_driver/tf_conn.h
@@ -0,0 +1,106 @@
+/**
+ * Copyright (c) 2011 Trusted Logic S.A.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#ifndef __TF_CONN_H__
+#define __TF_CONN_H__
+
+#include "tf_defs.h"
+
+/*
+ * Returns a pointer to the connection referenced by the
+ * specified file.
+ */
+static inline struct tf_connection *tf_conn_from_file(
+        struct file *file)
+{
+        return file->private_data;
+}
+
+int tf_validate_shmem_and_flags(u32 shmem, u32 shmem_size, u32 flags);
+
+int tf_map_shmem(
+                struct tf_connection *connection,
+                u32 buffer,
+                /* flags for read-write access rights on the memory */
+                u32 flags,
+                bool in_user_space,
+                u32 descriptors[TF_MAX_COARSE_PAGES],
+                u32 *buffer_start_offset,
+                u32 buffer_size,
+                struct tf_shmem_desc **shmem_desc,
+                u32 *descriptor_count);
+
+void tf_unmap_shmem(
+                struct tf_connection *connection,
+                struct tf_shmem_desc *shmem_desc,
+                u32 full_cleanup);
+
+/*----------------------------------------------------------------------------
+ * Connection operations to the Secure World
+ *----------------------------------------------------------------------------*/
+
+int tf_create_device_context(
+         struct tf_connection *connection);
+
+int tf_destroy_device_context(
+        struct tf_connection *connection);
+
+int tf_open_client_session(
+        struct tf_connection *connection,
+        union tf_command *command,
+        union tf_answer *answer);
+
+int tf_close_client_session(
+        struct tf_connection *connection,
+        union tf_command *command,
+        union tf_answer *answer);
+
+int tf_register_shared_memory(
+        struct tf_connection *connection,
+        union tf_command *command,
+        union tf_answer *answer);
+
+int tf_release_shared_memory(
+        struct tf_connection *connection,
+        union tf_command *command,
+        union tf_answer *answer);
+
+int tf_invoke_client_command(
+        struct tf_connection *connection,
+        union tf_command *command,
+        union tf_answer *answer);
+
+int tf_cancel_client_command(
+        struct tf_connection *connection,
+        union tf_command *command,
+        union tf_answer *answer);
+
+/*----------------------------------------------------------------------------
+ * Connection initialization and cleanup operations
+ *----------------------------------------------------------------------------*/
+
+int tf_open(struct tf_device *dev,
+        struct file *file,
+        struct tf_connection **connection);
+
+void tf_close(
+        struct tf_connection *connection);
+
+
+#endif  /* !defined(__TF_CONN_H__) */
diff --git a/security/tf_driver/tf_defs.h b/security/tf_driver/tf_defs.h
new file mode 100644
index 00000000000..ac209370c55
--- /dev/null
+++ b/security/tf_driver/tf_defs.h
@@ -0,0 +1,538 @@
+/**
+ * Copyright (c) 2011 Trusted Logic S.A.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#ifndef __TF_DEFS_H__
+#define __TF_DEFS_H__
+
+#include <linux/atomic.h>
+#include <linux/version.h>
+#include <linux/fs.h>
+#include <linux/cdev.h>
+#include <linux/completion.h>
+#include <linux/list.h>
+#include <linux/spinlock.h>
+#include <linux/sysfs.h>
+#include <linux/sched.h>
+#include <linux/semaphore.h>
+#ifdef CONFIG_HAS_WAKELOCK
+#include <linux/wakelock.h>
+#endif
+
+#include "tf_protocol.h"
+
+/*----------------------------------------------------------------------------*/
+
+#define SIZE_1KB 0x400
+
+/*
+ * Maximum number of shared memory blocks that can be reigsters in a connection
+ */
+#define TF_SHMEM_MAX_COUNT   (64)
+
+/*
+ * Describes the possible types of shared memories
+ *
+ * TF_SHMEM_TYPE_PREALLOC_REGISTERED_SHMEM :
+ *    The descriptor describes a registered shared memory.
+ *    Its coarse pages are preallocated when initializing the
+ *    connection
+ * TF_SHMEM_TYPE_REGISTERED_SHMEM :
+ *    The descriptor describes a registered shared memory.
+ *    Its coarse pages are not preallocated
+ * TF_SHMEM_TYPE_PM_HIBERNATE :
+ *    The descriptor describes a power management shared memory.
+ */
+enum TF_SHMEM_TYPE {
+        TF_SHMEM_TYPE_PREALLOC_REGISTERED_SHMEM = 0,
+        TF_SHMEM_TYPE_REGISTERED_SHMEM,
+        TF_SHMEM_TYPE_PM_HIBERNATE,
+};
+
+
+/*
+ * This structure contains a pointer on a coarse page table
+ */
+struct tf_coarse_page_table {
+        /*
+         * Identifies the coarse page table descriptor in
+         * free_coarse_page_tables list
+         */
+        struct list_head list;
+
+        /*
+         * The address of the coarse page table
+         */
+        u32 *descriptors;
+
+        /*
+         * The address of the array containing this coarse page table
+         */
+        struct tf_coarse_page_table_array *parent;
+};
+
+
+#define TF_PAGE_DESCRIPTOR_TYPE_NORMAL       0
+#define TF_PAGE_DESCRIPTOR_TYPE_PREALLOCATED 1
+
+/*
+ * This structure describes an array of up to 4 coarse page tables
+ * allocated within a single 4KB page.
+ */
+struct tf_coarse_page_table_array {
+        /*
+         * identifies the element in the coarse_page_table_arrays list
+         */
+        struct list_head list;
+
+        /*
+         * Type of page descriptor
+         * can take any of TF_PAGE_DESCRIPTOR_TYPE_XXX value
+         */
+        u32 type;
+
+        struct tf_coarse_page_table coarse_page_tables[4];
+
+        /*
+         * A counter of the number of coarse pages currently used
+         * the max value should be 4 (one coarse page table is 1KB while one
+         * page is 4KB)
+         */
+        u8 ref_count;
+};
+
+
+/*
+ * This structure describes a list of coarse page table arrays
+ * with some of the coarse page tables free. It is used
+ * when the driver needs to allocate a new coarse page
+ * table.
+ */
+struct tf_coarse_page_table_allocation_context {
+        /*
+         * The spin lock protecting concurrent access to the structure.
+         */
+        spinlock_t lock;
+
+        /*
+         * The list of allocated coarse page table arrays
+         */
+        struct list_head coarse_page_table_arrays;
+
+        /*
+         * The list of free coarse page tables
+         */
+        struct list_head free_coarse_page_tables;
+};
+
+
+/*
+ * Fully describes a shared memory block
+ */
+struct tf_shmem_desc {
+        /*
+         * Identifies the shared memory descriptor in the list of free shared
+         * memory descriptors
+         */
+        struct list_head list;
+
+        /*
+         * Identifies the type of shared memory descriptor
+         */
+        enum TF_SHMEM_TYPE type;
+
+        /*
+         * The identifier of the block of shared memory, as returned by the
+         * Secure World.
+         * This identifier is block field of a REGISTER_SHARED_MEMORY answer
+         */
+        u32 block_identifier;
+
+        /* Client buffer */
+        u8 *client_buffer;
+
+        /* Up to eight coarse page table context */
+        struct tf_coarse_page_table *coarse_pg_table[TF_MAX_COARSE_PAGES];
+
+        u32 coarse_pg_table_count;
+
+        /* Reference counter */
+        atomic_t ref_count;
+};
+
+
+/*----------------------------------------------------------------------------*/
+
+/*
+ * This structure describes the communication with the Secure World
+ *
+ * Note that this driver supports only one instance of the Secure World
+ */
+struct tf_comm {
+        /*
+         * The spin lock protecting concurrent access to the structure.
+         */
+        spinlock_t lock;
+
+        /*
+         * Bit vector with the following possible flags:
+         *    - TF_COMM_FLAG_IRQ_REQUESTED: If set, indicates that
+         *      the IRQ has been successfuly requested.
+         *    - TF_COMM_FLAG_TERMINATING: If set, indicates that the
+         *      communication with the Secure World is being terminated.
+         *      Transmissions to the Secure World are not permitted
+         *    - TF_COMM_FLAG_W3B_ALLOCATED: If set, indicates that the
+         *      W3B buffer has been allocated.
+         *
+         * This bit vector must be accessed with the kernel's atomic bitwise
+         * operations.
+         */
+        unsigned long flags;
+
+        /*
+         * The virtual address of the L1 shared buffer.
+         */
+        struct tf_l1_shared_buffer *l1_buffer;
+
+        /*
+         * The wait queue the client threads are waiting on.
+         */
+        wait_queue_head_t wait_queue;
+
+#ifdef CONFIG_TF_TRUSTZONE
+        /*
+         * The interrupt line used by the Secure World.
+         */
+        int soft_int_irq;
+
+        /* ----- W3B ----- */
+        /* shared memory descriptor to identify the W3B */
+        struct tf_shmem_desc w3b_shmem_desc;
+
+        /* Virtual address of the kernel allocated shared memory */
+        u32 w3b;
+
+        /* offset of data in shared memory coarse pages */
+        u32 w3b_shmem_offset;
+
+        u32 w3b_shmem_size;
+
+        struct tf_coarse_page_table_allocation_context
+                w3b_cpt_alloc_context;
+#endif
+#ifdef CONFIG_TF_ZEBRA
+        /*
+         * The SE SDP can only be initialized once...
+         */
+        int se_initialized;
+
+        /*
+         * Lock to be held by a client when executing an RPC
+         */
+        struct mutex rpc_mutex;
+
+        /*
+         * Lock to protect concurrent accesses to DMA channels
+         */
+        struct mutex dma_mutex;
+#endif
+};
+
+
+#define TF_COMM_FLAG_IRQ_REQUESTED              (0)
+#define TF_COMM_FLAG_PA_AVAILABLE               (1)
+#define TF_COMM_FLAG_TERMINATING                (2)
+#define TF_COMM_FLAG_W3B_ALLOCATED              (3)
+#define TF_COMM_FLAG_L1_SHARED_ALLOCATED        (4)
+
+/*----------------------------------------------------------------------------*/
+
+struct tf_device_stats {
+        atomic_t stat_pages_allocated;
+        atomic_t stat_memories_allocated;
+        atomic_t stat_pages_locked;
+};
+
+/*
+ * This structure describes the information about one device handled by the
+ * driver. Note that the driver supports only a single device. see the global
+ * variable g_tf_dev
+
+ */
+struct tf_device {
+        /*
+         * The kernel object for the device
+         */
+        struct kobject kobj;
+
+        /*
+         * The device number for the device.
+         */
+        dev_t dev_number;
+
+        /*
+         * Interfaces the char device with the kernel.
+         */
+        struct cdev cdev;
+
+#ifdef CONFIG_TF_TEEC
+        struct cdev cdev_teec;
+#endif
+
+#ifdef CONFIG_TF_ZEBRA
+        struct cdev cdev_ctrl;
+
+        /*
+         * Globals for CUS
+         */
+        /* Current key handles loaded in HWAs */
+        u32 aes1_key_context;
+        u32 des_key_context;
+        bool sham1_is_public;
+
+        /* Object used to serialize HWA accesses */
+        struct semaphore aes1_sema;
+        struct semaphore des_sema;
+        struct semaphore sha_sema;
+
+        /*
+         * An aligned and correctly shaped pre-allocated buffer used for DMA
+         * transfers
+         */
+        u32 dma_buffer_length;
+        u8 *dma_buffer;
+        dma_addr_t dma_buffer_phys;
+
+        /* Workspace allocated at boot time and reserved to the Secure World */
+        u32 workspace_addr;
+        u32 workspace_size;
+
+        /*
+        * A Mutex to provide exclusive locking of the ioctl()
+        */
+        struct mutex dev_mutex;
+#endif
+
+        /*
+         * Communications with the SM.
+         */
+        struct tf_comm sm;
+
+        /*
+         * Lists the connections attached to this device.  A connection is
+         * created each time a user space application "opens" a file descriptor
+         * on the driver
+         */
+        struct list_head connection_list;
+
+        /*
+         * The spin lock used to protect concurrent access to the connection
+         * list.
+         */
+        spinlock_t connection_list_lock;
+
+        struct tf_device_stats stats;
+};
+
+/*----------------------------------------------------------------------------*/
+/*
+ * This type describes a connection state.
+ * This is used to determine whether a message is valid or not.
+ *
+ * Messages are only valid in a certain device state.
+ * Messages may be invalidated between the start of the ioctl call and the
+ * moment the message is sent to the Secure World.
+ *
+ * TF_CONN_STATE_NO_DEVICE_CONTEXT :
+ *    The connection has no DEVICE_CONTEXT created and no
+ *    CREATE_DEVICE_CONTEXT being processed by the Secure World
+ * TF_CONN_STATE_CREATE_DEVICE_CONTEXT_SENT :
+ *    The connection has a CREATE_DEVICE_CONTEXT being processed by the Secure
+ *    World
+ * TF_CONN_STATE_VALID_DEVICE_CONTEXT :
+ *    The connection has a DEVICE_CONTEXT created and no
+ *    DESTROY_DEVICE_CONTEXT is being processed by the Secure World
+ * TF_CONN_STATE_DESTROY_DEVICE_CONTEXT_SENT :
+ *    The connection has a DESTROY_DEVICE_CONTEXT being processed by the Secure
+ *    World
+ */
+enum TF_CONN_STATE {
+        TF_CONN_STATE_NO_DEVICE_CONTEXT = 0,
+        TF_CONN_STATE_CREATE_DEVICE_CONTEXT_SENT,
+        TF_CONN_STATE_VALID_DEVICE_CONTEXT,
+        TF_CONN_STATE_DESTROY_DEVICE_CONTEXT_SENT
+};
+
+
+/*
+ *  This type describes the  status of the command.
+ *
+ *  PENDING:
+ *     The initial state; the command has not been sent yet.
+ *      SENT:
+ *     The command has been sent, we are waiting for an answer.
+ *      ABORTED:
+ *     The command cannot be sent because the device context is invalid.
+ *     Note that this only covers the case where some other thread
+ *     sent a DESTROY_DEVICE_CONTEXT command.
+ */
+enum TF_COMMAND_STATE {
+        TF_COMMAND_STATE_PENDING = 0,
+        TF_COMMAND_STATE_SENT,
+        TF_COMMAND_STATE_ABORTED
+};
+
+/*
+ * The origin of connection parameters such as login data and
+ * memory reference pointers.
+ *
+ * PROCESS: the calling process. All arguments must be validated.
+ * KERNEL: kernel code. All arguments can be trusted by this driver.
+ */
+enum TF_CONNECTION_OWNER {
+        TF_CONNECTION_OWNER_PROCESS = 0,
+        TF_CONNECTION_OWNER_KERNEL,
+};
+
+
+/*
+ * This structure describes a connection to the driver
+ * A connection is created each time an application opens a file descriptor on
+ * the driver
+ */
+struct tf_connection {
+        /*
+         * Identifies the connection in the list of the connections attached to
+         * the same device.
+         */
+        struct list_head list;
+
+        /*
+         * State of the connection.
+         */
+        enum TF_CONN_STATE state;
+
+        /*
+         * A pointer to the corresponding device structure
+         */
+        struct tf_device *dev;
+
+        /*
+         * A spinlock to use to access state
+         */
+        spinlock_t state_lock;
+
+        /*
+         * Counts the number of operations currently pending on the connection.
+         * (for debug only)
+         */
+        atomic_t pending_op_count;
+
+        /*
+         * A handle for the device context
+         */
+         u32 device_context;
+
+        /*
+         * Lists the used shared memory descriptors
+         */
+        struct list_head used_shmem_list;
+
+        /*
+         * Lists the free shared memory descriptors
+         */
+        struct list_head free_shmem_list;
+
+        /*
+         * A mutex to use to access this structure
+         */
+        struct mutex shmem_mutex;
+
+        /*
+         * Counts the number of shared memories registered.
+         */
+        atomic_t shmem_count;
+
+        /*
+         * Page to retrieve memory properties when
+         * registering shared memory through REGISTER_SHARED_MEMORY
+         * messages
+         */
+        struct vm_area_struct **vmas;
+
+        /*
+         * coarse page table allocation context
+         */
+        struct tf_coarse_page_table_allocation_context cpt_alloc_context;
+
+        /* The origin of connection parameters such as login data and
+           memory reference pointers. */
+        enum TF_CONNECTION_OWNER owner;
+
+#ifdef CONFIG_TF_ZEBRA
+        /* Lists all the Cryptoki Update Shortcuts */
+        struct list_head shortcut_list;
+
+        /* Lock to protect concurrent accesses to shortcut_list */
+        spinlock_t shortcut_list_lock;
+#endif
+};
+
+/*----------------------------------------------------------------------------*/
+
+/*
+ * The operation_id field of a message points to this structure.
+ * It is used to identify the thread that triggered the message transmission
+ * Whoever reads an answer can wake up that thread using the completion event
+ */
+struct tf_answer_struct {
+        bool answer_copied;
+        union tf_answer *answer;
+};
+
+/*----------------------------------------------------------------------------*/
+
+/**
+ * The ASCII-C string representation of the base name of the devices managed by
+ * this driver.
+ */
+#define TF_DEVICE_BASE_NAME     "tf_driver"
+
+
+/**
+ * The major and minor numbers of the registered character device driver.
+ * Only 1 instance of the driver is supported.
+ */
+#define TF_DEVICE_MINOR_NUMBER  (0)
+
+struct tf_device *tf_get_device(void);
+
+#define CLEAN_CACHE_CFG_MASK    (~0xC) /* 1111 0011 */
+
+/*----------------------------------------------------------------------------*/
+/*
+ * Kernel Differences
+ */
+
+#ifdef CONFIG_ANDROID
+#define GROUP_INFO              get_current_groups()
+#else
+#define GROUP_INFO              (current->group_info)
+#endif
+
+#endif  /* !defined(__TF_DEFS_H__) */
diff --git a/security/tf_driver/tf_device.c b/security/tf_driver/tf_device.c
new file mode 100644
index 00000000000..ad44b46c206
--- /dev/null
+++ b/security/tf_driver/tf_device.c
@@ -0,0 +1,796 @@
+/**
+ * Copyright (c) 2011 Trusted Logic S.A.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#include <linux/atomic.h>
+#include <linux/uaccess.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/mm.h>
+#include <linux/page-flags.h>
+#include <linux/pm.h>
+#include <linux/syscore_ops.h>
+#include <linux/vmalloc.h>
+#include <linux/signal.h>
+#ifdef CONFIG_ANDROID
+#include <linux/device.h>
+#endif
+
+#include "tf_protocol.h"
+#include "tf_defs.h"
+#include "tf_util.h"
+#include "tf_conn.h"
+#include "tf_comm.h"
+#ifdef CONFIG_TF_ZEBRA
+#include <plat/cpu.h>
+#include "tf_zebra.h"
+#endif
+#ifdef CONFIG_TF_DRIVER_CRYPTO_FIPS
+#include "tf_crypto.h"
+#endif
+
+#include "s_version.h"
+
+/*----------------------------------------------------------------------------
+ * Forward Declarations
+ *----------------------------------------------------------------------------*/
+
+/*
+ * Creates and registers the device to be managed by the specified driver.
+ *
+ * Returns zero upon successful completion, or an appropriate error code upon
+ * failure.
+ */
+static int tf_device_register(void);
+
+
+/*
+ * Implements the device Open callback.
+ */
+static int tf_device_open(
+                struct inode *inode,
+                struct file *file);
+
+
+/*
+ * Implements the device Release callback.
+ */
+static int tf_device_release(
+                struct inode *inode,
+                struct file *file);
+
+
+/*
+ * Implements the device ioctl callback.
+ */
+static long tf_device_ioctl(
+                struct file *file,
+                unsigned int ioctl_num,
+                unsigned long ioctl_param);
+
+
+/*
+ * Implements the device shutdown callback.
+ */
+static int tf_device_shutdown(void);
+
+
+/*
+ * Implements the device suspend callback.
+ */
+static int tf_device_suspend(void);
+
+
+/*
+ * Implements the device resume callback.
+ */
+static int tf_device_resume(void);
+
+
+/*---------------------------------------------------------------------------
+ * Module Parameters
+ *---------------------------------------------------------------------------*/
+
+/*
+ * The device major number used to register a unique character device driver.
+ * Let the default value be 122
+ */
+static int device_major_number = 122;
+
+module_param(device_major_number, int, 0000);
+MODULE_PARM_DESC(device_major_number,
+        "The device major number used to register a unique character "
+        "device driver");
+
+#ifdef CONFIG_TF_TRUSTZONE
+/**
+ * The softint interrupt line used by the Secure World.
+ */
+static int soft_interrupt = -1;
+
+module_param(soft_interrupt, int, 0000);
+MODULE_PARM_DESC(soft_interrupt,
+        "The softint interrupt line used by the Secure world");
+#endif
+
+#ifdef CONFIG_TF_DRIVER_DEBUG_SUPPORT
+unsigned tf_debug_level = UINT_MAX;
+module_param_named(debug, tf_debug_level, uint, 0644);
+#endif
+
+#ifdef CONFIG_TF_DRIVER_CRYPTO_FIPS
+char *tf_integrity_hmac_sha256_expected_value;
+module_param_named(hmac_sha256, tf_integrity_hmac_sha256_expected_value,
+                   charp, 0444);
+
+#ifdef CONFIG_TF_DRIVER_FAULT_INJECTION
+unsigned tf_fault_injection_mask;
+module_param_named(fault, tf_fault_injection_mask, uint, 0644);
+#endif
+
+int tf_self_test_blkcipher_align;
+module_param_named(post_align, tf_self_test_blkcipher_align, int, 0644);
+int tf_self_test_blkcipher_use_vmalloc;
+module_param_named(post_vmalloc, tf_self_test_blkcipher_use_vmalloc, int, 0644);
+#endif
+
+#ifdef CONFIG_ANDROID
+static struct class *tf_class;
+#endif
+
+/*----------------------------------------------------------------------------
+ * Global Variables
+ *----------------------------------------------------------------------------*/
+
+/*
+ * tf_driver character device definitions.
+ * read and write methods are not defined
+ * and will return an error if used by user space
+ */
+static const struct file_operations g_tf_device_file_ops = {
+        .owner = THIS_MODULE,
+        .open = tf_device_open,
+        .release = tf_device_release,
+        .unlocked_ioctl = tf_device_ioctl,
+        .llseek = no_llseek,
+};
+
+
+static struct syscore_ops g_tf_device_syscore_ops = {
+        .shutdown = tf_device_shutdown,
+        .suspend = tf_device_suspend,
+        .resume = tf_device_resume,
+};
+
+/* The single device supported by this driver */
+static struct tf_device g_tf_dev;
+
+/*----------------------------------------------------------------------------
+ * Implementations
+ *----------------------------------------------------------------------------*/
+
+struct tf_device *tf_get_device(void)
+{
+        return &g_tf_dev;
+}
+
+/*
+ * sysfs entries
+ */
+struct tf_sysfs_entry {
+        struct attribute attr;
+        ssize_t (*show)(struct tf_device *, char *);
+        ssize_t (*store)(struct tf_device *, const char *, size_t);
+};
+
+/*
+ * sysfs entry showing allocation stats
+ */
+static ssize_t info_show(struct tf_device *dev, char *buf)
+{
+        struct tf_device_stats *dev_stats = &dev->stats;
+
+        return snprintf(buf, PAGE_SIZE,
+                "stat.memories.allocated: %d\n"
+                "stat.pages.allocated:    %d\n"
+                "stat.pages.locked:       %d\n",
+                atomic_read(&dev_stats->stat_memories_allocated),
+                atomic_read(&dev_stats->stat_pages_allocated),
+                atomic_read(&dev_stats->stat_pages_locked));
+}
+static struct tf_sysfs_entry tf_info_entry = __ATTR_RO(info);
+
+#ifdef CONFIG_TF_ZEBRA
+/*
+ * sysfs entry showing whether secure world is up and running
+ */
+static ssize_t tf_started_show(struct tf_device *dev, char *buf)
+{
+        int tf_started = test_bit(TF_COMM_FLAG_PA_AVAILABLE,
+                &dev->sm.flags);
+
+        return snprintf(buf, PAGE_SIZE, "%s\n", tf_started ? "yes" : "no");
+}
+static struct tf_sysfs_entry tf_started_entry =
+        __ATTR_RO(tf_started);
+
+static ssize_t workspace_addr_show(struct tf_device *dev, char *buf)
+{
+        return snprintf(buf, PAGE_SIZE, "0x%08x\n", dev->workspace_addr);
+}
+static struct tf_sysfs_entry tf_workspace_addr_entry =
+        __ATTR_RO(workspace_addr);
+
+static ssize_t workspace_size_show(struct tf_device *dev, char *buf)
+{
+        return snprintf(buf, PAGE_SIZE, "0x%08x\n", dev->workspace_size);
+}
+static struct tf_sysfs_entry tf_workspace_size_entry =
+        __ATTR_RO(workspace_size);
+#endif
+
+static ssize_t tf_attr_show(struct kobject *kobj, struct attribute *attr,
+        char *page)
+{
+        struct tf_sysfs_entry *entry = container_of(attr, struct tf_sysfs_entry,
+                attr);
+        struct tf_device *dev = container_of(kobj, struct tf_device, kobj);
+
+        if (!entry->show)
+                return -EIO;
+
+        return entry->show(dev, page);
+}
+
+static ssize_t tf_attr_store(struct kobject *kobj, struct attribute *attr,
+        const char *page, size_t length)
+{
+        struct tf_sysfs_entry *entry = container_of(attr, struct tf_sysfs_entry,
+                attr);
+        struct tf_device *dev = container_of(kobj, struct tf_device, kobj);
+
+        if (!entry->store)
+                return -EIO;
+
+        return entry->store(dev, page, length);
+}
+
+static void tf_kobj_release(struct kobject *kobj) {}
+
+static struct attribute *tf_default_attrs[] = {
+        &tf_info_entry.attr,
+#ifdef CONFIG_TF_ZEBRA
+        &tf_started_entry.attr,
+        &tf_workspace_addr_entry.attr,
+        &tf_workspace_size_entry.attr,
+#endif
+        NULL,
+};
+static const struct sysfs_ops tf_sysfs_ops = {
+        .show   = tf_attr_show,
+        .store  = tf_attr_store,
+};
+static struct kobj_type tf_ktype = {
+        .release        = tf_kobj_release,
+        .sysfs_ops      = &tf_sysfs_ops,
+        .default_attrs  = tf_default_attrs
+};
+
+/*----------------------------------------------------------------------------*/
+
+#if defined(MODULE) && defined(CONFIG_TF_ZEBRA)
+static char *smc_mem;
+module_param(smc_mem, charp, S_IRUGO);
+#endif
+
+/*
+ * First routine called when the kernel module is loaded
+ */
+static int __init tf_device_register(void)
+{
+        int error;
+        struct tf_device *dev = &g_tf_dev;
+
+        dprintk(KERN_INFO "tf_device_register()\n");
+
+        /*
+         * Initialize the device
+         */
+        dev->dev_number = MKDEV(device_major_number,
+                TF_DEVICE_MINOR_NUMBER);
+        cdev_init(&dev->cdev, &g_tf_device_file_ops);
+        dev->cdev.owner = THIS_MODULE;
+
+        INIT_LIST_HEAD(&dev->connection_list);
+        spin_lock_init(&dev->connection_list_lock);
+
+#if defined(MODULE) && defined(CONFIG_TF_ZEBRA)
+        error = (*tf_comm_early_init)();
+        if (error)
+                goto module_early_init_failed;
+
+        error = tf_device_mshield_init(smc_mem);
+        if (error)
+                goto mshield_init_failed;
+
+#ifdef CONFIG_TF_DRIVER_CRYPTO_FIPS
+        error = tf_crypto_hmac_module_init();
+        if (error)
+                goto hmac_init_failed;
+
+        error = tf_self_test_register_device();
+        if (error)
+                goto self_test_register_device_failed;
+#endif
+#endif
+
+        /* register the sysfs object driver stats */
+        error = kobject_init_and_add(&dev->kobj,  &tf_ktype, NULL, "%s",
+                 TF_DEVICE_BASE_NAME);
+        if (error) {
+                printk(KERN_ERR "tf_device_register(): "
+                        "kobject_init_and_add failed (error %d)!\n", error);
+                kobject_put(&dev->kobj);
+                goto kobject_init_and_add_failed;
+        }
+
+        /*
+         * Register the system device.
+         */
+        register_syscore_ops(&g_tf_device_syscore_ops);
+
+        /*
+         * Register the char device.
+         */
+        printk(KERN_INFO "Registering char device %s (%u:%u)\n",
+                TF_DEVICE_BASE_NAME,
+                MAJOR(dev->dev_number),
+                MINOR(dev->dev_number));
+        error = register_chrdev_region(dev->dev_number, 1,
+                TF_DEVICE_BASE_NAME);
+        if (error != 0) {
+                printk(KERN_ERR "tf_device_register():"
+                        " register_chrdev_region failed (error %d)!\n",
+                        error);
+                goto register_chrdev_region_failed;
+        }
+
+        error = cdev_add(&dev->cdev, dev->dev_number, 1);
+        if (error != 0) {
+                printk(KERN_ERR "tf_device_register(): "
+                        "cdev_add failed (error %d)!\n",
+                        error);
+                goto cdev_add_failed;
+        }
+
+        /*
+         * Initialize the communication with the Secure World.
+         */
+#ifdef CONFIG_TF_TRUSTZONE
+        dev->sm.soft_int_irq = soft_interrupt;
+#endif
+        error = tf_init(&g_tf_dev.sm);
+        if (error != S_SUCCESS) {
+                dprintk(KERN_ERR "tf_device_register(): "
+                        "tf_init failed (error %d)!\n",
+                        error);
+                goto init_failed;
+        }
+
+#ifdef CONFIG_TF_DRIVER_CRYPTO_FIPS
+        error = tf_self_test_post_init(&(dev_stats->kobj));
+        /* N.B. error > 0 indicates a POST failure, which will not
+           prevent the module from loading. */
+        if (error < 0) {
+                dprintk(KERN_ERR "tf_device_register(): "
+                        "tf_self_test_post_vectors failed (error %d)!\n",
+                        error);
+                goto post_failed;
+        }
+#endif
+
+#ifdef CONFIG_ANDROID
+        tf_class = class_create(THIS_MODULE, TF_DEVICE_BASE_NAME);
+        device_create(tf_class, NULL,
+                dev->dev_number,
+                NULL, TF_DEVICE_BASE_NAME);
+#endif
+
+#ifdef CONFIG_TF_ZEBRA
+        /*
+         * Initializes the /dev/tf_ctrl device node.
+         */
+        error = tf_ctrl_device_register();
+        if (error)
+                goto ctrl_failed;
+#endif
+
+#ifdef CONFIG_TF_DRIVER_DEBUG_SUPPORT
+        address_cache_property((unsigned long) &tf_device_register);
+#endif
+        /*
+         * Successful completion.
+         */
+
+        dprintk(KERN_INFO "tf_device_register(): Success\n");
+        return 0;
+
+        /*
+         * Error: undo all operations in the reverse order
+         */
+#ifdef CONFIG_TF_ZEBRA
+ctrl_failed:
+#endif
+#ifdef CONFIG_TF_DRIVER_CRYPTO_FIPS
+        tf_self_test_post_exit();
+post_failed:
+#endif
+init_failed:
+        cdev_del(&dev->cdev);
+cdev_add_failed:
+        unregister_chrdev_region(dev->dev_number, 1);
+register_chrdev_region_failed:
+        unregister_syscore_ops(&g_tf_device_syscore_ops);
+kobject_init_and_add_failed:
+        kobject_del(&g_tf_dev.kobj);
+
+#if defined(MODULE) && defined(CONFIG_TF_ZEBRA)
+#ifdef CONFIG_TF_DRIVER_CRYPTO_FIPS
+        tf_self_test_unregister_device();
+self_test_register_device_failed:
+        tf_crypto_hmac_module_exit();
+hmac_init_failed:
+#endif
+        tf_device_mshield_exit();
+mshield_init_failed:
+module_early_init_failed:
+#endif
+        dprintk(KERN_INFO "tf_device_register(): Failure (error %d)\n",
+                error);
+        return error;
+}
+
+/*----------------------------------------------------------------------------*/
+
+static int tf_device_open(struct inode *inode, struct file *file)
+{
+        int error;
+        struct tf_device *dev = &g_tf_dev;
+        struct tf_connection *connection = NULL;
+
+        dprintk(KERN_INFO "tf_device_open(%u:%u, %p)\n",
+                imajor(inode), iminor(inode), file);
+
+        /* Dummy lseek for non-seekable driver */
+        error = nonseekable_open(inode, file);
+        if (error != 0) {
+                dprintk(KERN_ERR "tf_device_open(%p): "
+                        "nonseekable_open failed (error %d)!\n",
+                        file, error);
+                goto error;
+        }
+
+#ifndef CONFIG_ANDROID
+        /*
+         * Check file flags. We only autthorize the O_RDWR access
+         */
+        if (file->f_flags != O_RDWR) {
+                dprintk(KERN_ERR "tf_device_open(%p): "
+                        "Invalid access mode %u\n",
+                        file, file->f_flags);
+                error = -EACCES;
+                goto error;
+        }
+#endif
+
+        /*
+         * Open a new connection.
+         */
+
+        error = tf_open(dev, file, &connection);
+        if (error != 0) {
+                dprintk(KERN_ERR "tf_device_open(%p): "
+                        "tf_open failed (error %d)!\n",
+                        file, error);
+                goto error;
+        }
+
+        file->private_data = connection;
+
+        /*
+         * Send the CreateDeviceContext command to the secure
+         */
+        error = tf_create_device_context(connection);
+        if (error != 0) {
+                dprintk(KERN_ERR "tf_device_open(%p): "
+                        "tf_create_device_context failed (error %d)!\n",
+                        file, error);
+                goto error1;
+        }
+
+        /*
+         * Successful completion.
+         */
+
+        dprintk(KERN_INFO "tf_device_open(%p): Success (connection=%p)\n",
+                file, connection);
+        return 0;
+
+        /*
+         * Error handling.
+         */
+
+error1:
+        tf_close(connection);
+error:
+        dprintk(KERN_INFO "tf_device_open(%p): Failure (error %d)\n",
+                file, error);
+        return error;
+}
+
+/*----------------------------------------------------------------------------*/
+
+static int tf_device_release(struct inode *inode, struct file *file)
+{
+        struct tf_connection *connection;
+
+        dprintk(KERN_INFO "tf_device_release(%u:%u, %p)\n",
+                imajor(inode), iminor(inode), file);
+
+        connection = tf_conn_from_file(file);
+        tf_close(connection);
+
+        dprintk(KERN_INFO "tf_device_release(%p): Success\n", file);
+        return 0;
+}
+
+/*----------------------------------------------------------------------------*/
+
+static long tf_device_ioctl(struct file *file, unsigned int ioctl_num,
+        unsigned long ioctl_param)
+{
+        int result = S_SUCCESS;
+        struct tf_connection *connection;
+        union tf_command command;
+        struct tf_command_header header;
+        union tf_answer answer;
+        u32 command_size;
+        u32 answer_size;
+        void *user_answer;
+
+        dprintk(KERN_INFO "tf_device_ioctl(%p, %u, %p)\n",
+                file, ioctl_num, (void *) ioctl_param);
+
+        switch (ioctl_num) {
+        case IOCTL_TF_GET_VERSION:
+                /* ioctl is asking for the driver interface version */
+                result = TF_DRIVER_INTERFACE_VERSION;
+                goto exit;
+
+        case IOCTL_TF_EXCHANGE:
+                /*
+                 * ioctl is asking to perform a message exchange with the Secure
+                 * Module
+                 */
+
+                /*
+                 * Make a local copy of the data from the user application
+                 * This routine checks the data is readable
+                 *
+                 * Get the header first.
+                 */
+                if (copy_from_user(&header,
+                                (struct tf_command_header *)ioctl_param,
+                                sizeof(struct tf_command_header))) {
+                        dprintk(KERN_ERR "tf_device_ioctl(%p): "
+                                "Cannot access ioctl parameter %p\n",
+                                file, (void *) ioctl_param);
+                        result = -EFAULT;
+                        goto exit;
+                }
+
+                /* size in words of u32 */
+                command_size = header.message_size +
+                        sizeof(struct tf_command_header)/sizeof(u32);
+                if (command_size > sizeof(command)/sizeof(u32)) {
+                        dprintk(KERN_ERR "tf_device_ioctl(%p): "
+                                "Buffer overflow: too many bytes to copy %d\n",
+                                file, command_size);
+                        result = -EFAULT;
+                        goto exit;
+                }
+
+                if (copy_from_user(&command,
+                                (union tf_command *)ioctl_param,
+                                command_size * sizeof(u32))) {
+                        dprintk(KERN_ERR "tf_device_ioctl(%p): "
+                                "Cannot access ioctl parameter %p\n",
+                                file, (void *) ioctl_param);
+                        result = -EFAULT;
+                        goto exit;
+                }
+
+                connection = tf_conn_from_file(file);
+                BUG_ON(connection == NULL);
+
+                /*
+                 * The answer memory space address is in the operation_id field
+                 */
+                user_answer = (void *) command.header.operation_id;
+
+                atomic_inc(&(connection->pending_op_count));
+
+                dprintk(KERN_WARNING "tf_device_ioctl(%p): "
+                        "Sending message type  0x%08x\n",
+                        file, command.header.message_type);
+
+                switch (command.header.message_type) {
+                case TF_MESSAGE_TYPE_OPEN_CLIENT_SESSION:
+                        result = tf_open_client_session(connection,
+                                &command, &answer);
+                        break;
+
+                case TF_MESSAGE_TYPE_CLOSE_CLIENT_SESSION:
+                        result = tf_close_client_session(connection,
+                                &command, &answer);
+                        break;
+
+                case TF_MESSAGE_TYPE_REGISTER_SHARED_MEMORY:
+                        result = tf_register_shared_memory(connection,
+                                &command, &answer);
+                        break;
+
+                case TF_MESSAGE_TYPE_RELEASE_SHARED_MEMORY:
+                        result = tf_release_shared_memory(connection,
+                                &command, &answer);
+                        break;
+
+                case TF_MESSAGE_TYPE_INVOKE_CLIENT_COMMAND:
+                        result = tf_invoke_client_command(connection,
+                                &command, &answer);
+                        break;
+
+                case TF_MESSAGE_TYPE_CANCEL_CLIENT_COMMAND:
+                        result = tf_cancel_client_command(connection,
+                                &command, &answer);
+                        break;
+
+                default:
+                        dprintk(KERN_ERR "tf_device_ioctl(%p): "
+                                "Incorrect message type (0x%08x)!\n",
+                                connection, command.header.message_type);
+                        result = -EOPNOTSUPP;
+                        break;
+                }
+
+                atomic_dec(&(connection->pending_op_count));
+
+                if (result != 0) {
+                        dprintk(KERN_WARNING "tf_device_ioctl(%p): "
+                                "Operation returning error code 0x%08x)!\n",
+                                file, result);
+                        goto exit;
+                }
+
+                /*
+                 * Copy the answer back to the user space application.
+                 * The driver does not check this field, only copy back to user
+                 * space the data handed over by Secure World
+                 */
+                answer_size = answer.header.message_size +
+                        sizeof(struct tf_answer_header)/sizeof(u32);
+                if (copy_to_user(user_answer,
+                                &answer, answer_size * sizeof(u32))) {
+                        dprintk(KERN_WARNING "tf_device_ioctl(%p): "
+                                "Failed to copy back the full command "
+                                "answer to %p\n", file, user_answer);
+                        result = -EFAULT;
+                        goto exit;
+                }
+
+                /* successful completion */
+                dprintk(KERN_INFO "tf_device_ioctl(%p): Success\n", file);
+                break;
+
+        case  IOCTL_TF_GET_DESCRIPTION: {
+                /* ioctl asking for the version information buffer */
+                struct tf_version_information_buffer *pInfoBuffer;
+
+                dprintk(KERN_INFO "IOCTL_TF_GET_DESCRIPTION:(%p, %u, %p)\n",
+                        file, ioctl_num, (void *) ioctl_param);
+
+                pInfoBuffer =
+                        ((struct tf_version_information_buffer *) ioctl_param);
+
+                dprintk(KERN_INFO "IOCTL_TF_GET_DESCRIPTION1: "
+                        "driver_description=\"%64s\"\n", S_VERSION_STRING);
+
+                if (copy_to_user(pInfoBuffer->driver_description,
+                                S_VERSION_STRING,
+                                strlen(S_VERSION_STRING) + 1)) {
+                        dprintk(KERN_ERR "tf_device_ioctl(%p): "
+                                "Fail to copy back the driver description "
+                                "to  %p\n",
+                                file, pInfoBuffer->driver_description);
+                        result = -EFAULT;
+                        goto exit;
+                }
+
+                dprintk(KERN_INFO "IOCTL_TF_GET_DESCRIPTION2: "
+                        "secure_world_description=\"%64s\"\n",
+                        tf_get_description(&g_tf_dev.sm));
+
+                if (copy_to_user(pInfoBuffer->secure_world_description,
+                                tf_get_description(&g_tf_dev.sm),
+                                TF_DESCRIPTION_BUFFER_LENGTH)) {
+                        dprintk(KERN_WARNING "tf_device_ioctl(%p): "
+                                "Failed to copy back the secure world "
+                                "description to %p\n",
+                                file, pInfoBuffer->secure_world_description);
+                        result = -EFAULT;
+                        goto exit;
+                }
+                break;
+        }
+
+        default:
+                dprintk(KERN_ERR "tf_device_ioctl(%p): "
+                        "Unknown IOCTL code 0x%08x!\n",
+                        file, ioctl_num);
+                result = -EOPNOTSUPP;
+                goto exit;
+        }
+
+exit:
+        return result;
+}
+
+/*----------------------------------------------------------------------------*/
+
+static int tf_device_shutdown(void)
+{
+
+        return tf_power_management(&g_tf_dev.sm,
+                TF_POWER_OPERATION_SHUTDOWN);
+}
+
+/*----------------------------------------------------------------------------*/
+
+static int tf_device_suspend(void)
+{
+        dprintk(KERN_INFO "tf_device_suspend: Enter\n");
+        return tf_power_management(&g_tf_dev.sm,
+                TF_POWER_OPERATION_HIBERNATE);
+}
+
+
+/*----------------------------------------------------------------------------*/
+
+static int tf_device_resume(void)
+{
+        return tf_power_management(&g_tf_dev.sm,
+                TF_POWER_OPERATION_RESUME);
+}
+
+
+/*----------------------------------------------------------------------------*/
+
+module_init(tf_device_register);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Trusted Logic S.A.");
diff --git a/security/tf_driver/tf_protocol.h b/security/tf_driver/tf_protocol.h
new file mode 100644
index 00000000000..403df8ec8ef
--- /dev/null
+++ b/security/tf_driver/tf_protocol.h
@@ -0,0 +1,690 @@
+/**
+ * Copyright (c) 2011 Trusted Logic S.A.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#ifndef __TF_PROTOCOL_H__
+#define __TF_PROTOCOL_H__
+
+/*----------------------------------------------------------------------------
+ *
+ * This header file defines the structure used in the SChannel Protocol.
+ * See your Product Reference Manual for a specification of the SChannel
+ * protocol.
+ *---------------------------------------------------------------------------*/
+
+/*
+ * The driver interface version returned by the version ioctl
+ */
+#define TF_DRIVER_INTERFACE_VERSION     0x04000000
+
+/*
+ * Protocol version handling
+ */
+#define TF_S_PROTOCOL_MAJOR_VERSION  (0x06)
+#define GET_PROTOCOL_MAJOR_VERSION(a) (a >> 24)
+#define GET_PROTOCOL_MINOR_VERSION(a) ((a >> 16) & 0xFF)
+
+/*
+ * The S flag of the config_flag_s register.
+ */
+#define TF_CONFIG_FLAG_S   (1 << 3)
+
+/*
+ * The TimeSlot field of the sync_serial_n register.
+ */
+#define TF_SYNC_SERIAL_TIMESLOT_N   (1)
+
+/*
+ * status_s related defines.
+ */
+#define TF_STATUS_P_MASK            (0X00000001)
+#define TF_STATUS_POWER_STATE_SHIFT (3)
+#define TF_STATUS_POWER_STATE_MASK  (0x1F << TF_STATUS_POWER_STATE_SHIFT)
+
+/*
+ * Possible power states of the POWER_STATE field of the status_s register
+ */
+#define TF_POWER_MODE_COLD_BOOT          (0)
+#define TF_POWER_MODE_WARM_BOOT          (1)
+#define TF_POWER_MODE_ACTIVE             (3)
+#define TF_POWER_MODE_READY_TO_SHUTDOWN  (5)
+#define TF_POWER_MODE_READY_TO_HIBERNATE (7)
+#define TF_POWER_MODE_WAKEUP             (8)
+#define TF_POWER_MODE_PANIC              (15)
+
+/*
+ * Possible command values for MANAGEMENT commands
+ */
+#define TF_MANAGEMENT_HIBERNATE            (1)
+#define TF_MANAGEMENT_SHUTDOWN             (2)
+#define TF_MANAGEMENT_PREPARE_FOR_CORE_OFF (3)
+#define TF_MANAGEMENT_RESUME_FROM_CORE_OFF (4)
+
+/*
+ * The capacity of the Normal Word message queue, in number of slots.
+ */
+#define TF_N_MESSAGE_QUEUE_CAPACITY  (512)
+
+/*
+ * The capacity of the Secure World message answer queue, in number of slots.
+ */
+#define TF_S_ANSWER_QUEUE_CAPACITY  (256)
+
+/*
+ * The value of the S-timeout register indicating an infinite timeout.
+ */
+#define TF_S_TIMEOUT_0_INFINITE  (0xFFFFFFFF)
+#define TF_S_TIMEOUT_1_INFINITE  (0xFFFFFFFF)
+
+/*
+ * The value of the S-timeout register indicating an immediate timeout.
+ */
+#define TF_S_TIMEOUT_0_IMMEDIATE  (0x0)
+#define TF_S_TIMEOUT_1_IMMEDIATE  (0x0)
+
+/*
+ * Identifies the get protocol version SMC.
+ */
+#define TF_SMC_GET_PROTOCOL_VERSION (0XFFFFFFFB)
+
+/*
+ * Identifies the init SMC.
+ */
+#define TF_SMC_INIT                 (0XFFFFFFFF)
+
+/*
+ * Identifies the reset irq SMC.
+ */
+#define TF_SMC_RESET_IRQ            (0xFFFFFFFE)
+
+/*
+ * Identifies the SET_W3B SMC.
+ */
+#define TF_SMC_WAKE_UP              (0xFFFFFFFD)
+
+/*
+ * Identifies the STOP SMC.
+ */
+#define TF_SMC_STOP                 (0xFFFFFFFC)
+
+/*
+ * Identifies the n-yield SMC.
+ */
+#define TF_SMC_N_YIELD              (0X00000003)
+
+
+/* Possible stop commands for SMC_STOP */
+#define SCSTOP_HIBERNATE           (0xFFFFFFE1)
+#define SCSTOP_SHUTDOWN            (0xFFFFFFE2)
+
+/*
+ * representation of an UUID.
+ */
+struct tf_uuid {
+        u32 time_low;
+        u16 time_mid;
+        u16 time_hi_and_version;
+        u8 clock_seq_and_node[8];
+};
+
+
+/**
+ * Command parameters.
+ */
+struct tf_command_param_value {
+        u32    a;
+        u32    b;
+};
+
+struct tf_command_param_temp_memref {
+        u32    descriptor; /* data pointer for exchange message.*/
+        u32    size;
+        u32    offset;
+};
+
+struct tf_command_param_memref {
+        u32      block;
+        u32      size;
+        u32      offset;
+};
+
+union tf_command_param {
+        struct tf_command_param_value        value;
+        struct tf_command_param_temp_memref  temp_memref;
+        struct tf_command_param_memref       memref;
+};
+
+/**
+ * Answer parameters.
+ */
+struct tf_answer_param_value {
+        u32   a;
+        u32   b;
+};
+
+struct tf_answer_param_size {
+        u32   _ignored;
+        u32   size;
+};
+
+union tf_answer_param {
+        struct tf_answer_param_size    size;
+        struct tf_answer_param_value   value;
+};
+
+/*
+ * Descriptor tables capacity
+ */
+#define TF_MAX_W3B_COARSE_PAGES                 (2)
+/* TF_MAX_COARSE_PAGES is the number of level 1 descriptors (describing
+ * 1MB each) that can be shared with the secure world in a single registered
+ * shared memory block. It must be kept in synch with
+ * SCHANNEL6_MAX_DESCRIPTORS_PER_REGISTERED_SHARED_MEM in the SChannel
+ * protocol spec. */
+#define TF_MAX_COARSE_PAGES                     128
+#define TF_DESCRIPTOR_TABLE_CAPACITY_BIT_SHIFT  (8)
+#define TF_DESCRIPTOR_TABLE_CAPACITY \
+        (1 << TF_DESCRIPTOR_TABLE_CAPACITY_BIT_SHIFT)
+#define TF_DESCRIPTOR_TABLE_CAPACITY_MASK \
+        (TF_DESCRIPTOR_TABLE_CAPACITY - 1)
+/* Shared memories coarse pages can map up to 1MB */
+#define TF_MAX_COARSE_PAGE_MAPPED_SIZE \
+        (PAGE_SIZE * TF_DESCRIPTOR_TABLE_CAPACITY)
+/* Shared memories cannot exceed 8MB */
+#define TF_MAX_SHMEM_SIZE \
+        (TF_MAX_COARSE_PAGE_MAPPED_SIZE << 3)
+
+/*
+ * Buffer size for version description fields
+ */
+#define TF_DESCRIPTION_BUFFER_LENGTH 64
+
+/*
+ * Shared memory type flags.
+ */
+#define TF_SHMEM_TYPE_READ         (0x00000001)
+#define TF_SHMEM_TYPE_WRITE        (0x00000002)
+
+/*
+ * Shared mem flags
+ */
+#define TF_SHARED_MEM_FLAG_INPUT   1
+#define TF_SHARED_MEM_FLAG_OUTPUT  2
+#define TF_SHARED_MEM_FLAG_INOUT   3
+
+
+/*
+ * Parameter types
+ */
+#define TF_PARAM_TYPE_NONE               0x0
+#define TF_PARAM_TYPE_VALUE_INPUT        0x1
+#define TF_PARAM_TYPE_VALUE_OUTPUT       0x2
+#define TF_PARAM_TYPE_VALUE_INOUT        0x3
+#define TF_PARAM_TYPE_MEMREF_TEMP_INPUT  0x5
+#define TF_PARAM_TYPE_MEMREF_TEMP_OUTPUT 0x6
+#define TF_PARAM_TYPE_MEMREF_TEMP_INOUT  0x7
+#define TF_PARAM_TYPE_MEMREF_INPUT       0xD
+#define TF_PARAM_TYPE_MEMREF_OUTPUT      0xE
+#define TF_PARAM_TYPE_MEMREF_INOUT       0xF
+
+#define TF_PARAM_TYPE_MEMREF_FLAG               0x4
+#define TF_PARAM_TYPE_REGISTERED_MEMREF_FLAG    0x8
+
+
+#define TF_MAKE_PARAM_TYPES(t0, t1, t2, t3) \
+        ((t0) | ((t1) << 4) | ((t2) << 8) | ((t3) << 12))
+#define TF_GET_PARAM_TYPE(t, i) (((t) >> (4 * i)) & 0xF)
+
+/*
+ * Login types.
+ */
+#define TF_LOGIN_PUBLIC              0x00000000
+#define TF_LOGIN_USER                0x00000001
+#define TF_LOGIN_GROUP               0x00000002
+#define TF_LOGIN_APPLICATION         0x00000004
+#define TF_LOGIN_APPLICATION_USER    0x00000005
+#define TF_LOGIN_APPLICATION_GROUP   0x00000006
+#define TF_LOGIN_AUTHENTICATION      0x80000000
+#define TF_LOGIN_PRIVILEGED          0x80000002
+
+/* Login variants */
+
+#define TF_LOGIN_VARIANT(main_type, os, variant) \
+        ((main_type) | (1 << 27) | ((os) << 16) | ((variant) << 8))
+
+#define TF_LOGIN_GET_MAIN_TYPE(type) \
+        ((type) & ~TF_LOGIN_VARIANT(0, 0xFF, 0xFF))
+
+#define TF_LOGIN_OS_ANY       0x00
+#define TF_LOGIN_OS_LINUX     0x01
+#define TF_LOGIN_OS_ANDROID   0x04
+
+/* OS-independent variants */
+#define TF_LOGIN_USER_NONE \
+        TF_LOGIN_VARIANT(TF_LOGIN_USER, TF_LOGIN_OS_ANY, 0xFF)
+#define TF_LOGIN_GROUP_NONE \
+        TF_LOGIN_VARIANT(TF_LOGIN_GROUP, TF_LOGIN_OS_ANY, 0xFF)
+#define TF_LOGIN_APPLICATION_USER_NONE \
+        TF_LOGIN_VARIANT(TF_LOGIN_APPLICATION_USER, TF_LOGIN_OS_ANY, 0xFF)
+#define TF_LOGIN_AUTHENTICATION_BINARY_SHA1_HASH \
+        TF_LOGIN_VARIANT(TF_LOGIN_AUTHENTICATION, TF_LOGIN_OS_ANY, 0x01)
+#define TF_LOGIN_PRIVILEGED_KERNEL \
+        TF_LOGIN_VARIANT(TF_LOGIN_PRIVILEGED, TF_LOGIN_OS_ANY, 0x01)
+
+/* Linux variants */
+#define TF_LOGIN_USER_LINUX_EUID \
+        TF_LOGIN_VARIANT(TF_LOGIN_USER, TF_LOGIN_OS_LINUX, 0x01)
+#define TF_LOGIN_GROUP_LINUX_GID \
+        TF_LOGIN_VARIANT(TF_LOGIN_GROUP, TF_LOGIN_OS_LINUX, 0x01)
+#define TF_LOGIN_APPLICATION_LINUX_PATH_SHA1_HASH \
+        TF_LOGIN_VARIANT(TF_LOGIN_APPLICATION, TF_LOGIN_OS_LINUX, 0x01)
+#define TF_LOGIN_APPLICATION_USER_LINUX_PATH_EUID_SHA1_HASH \
+        TF_LOGIN_VARIANT(TF_LOGIN_APPLICATION_USER, TF_LOGIN_OS_LINUX, 0x01)
+#define TF_LOGIN_APPLICATION_GROUP_LINUX_PATH_GID_SHA1_HASH \
+        TF_LOGIN_VARIANT(TF_LOGIN_APPLICATION_GROUP, TF_LOGIN_OS_LINUX, 0x01)
+
+/* Android variants */
+#define TF_LOGIN_USER_ANDROID_EUID \
+        TF_LOGIN_VARIANT(TF_LOGIN_USER, TF_LOGIN_OS_ANDROID, 0x01)
+#define TF_LOGIN_GROUP_ANDROID_GID \
+        TF_LOGIN_VARIANT(TF_LOGIN_GROUP, TF_LOGIN_OS_ANDROID, 0x01)
+#define TF_LOGIN_APPLICATION_ANDROID_UID \
+        TF_LOGIN_VARIANT(TF_LOGIN_APPLICATION, TF_LOGIN_OS_ANDROID, 0x01)
+#define TF_LOGIN_APPLICATION_USER_ANDROID_UID_EUID \
+        TF_LOGIN_VARIANT(TF_LOGIN_APPLICATION_USER, TF_LOGIN_OS_ANDROID, \
+                0x01)
+#define TF_LOGIN_APPLICATION_GROUP_ANDROID_UID_GID \
+        TF_LOGIN_VARIANT(TF_LOGIN_APPLICATION_GROUP, TF_LOGIN_OS_ANDROID, \
+                0x01)
+
+/*
+ *  return origins
+ */
+#define TF_ORIGIN_COMMS       2
+#define TF_ORIGIN_TEE         3
+#define TF_ORIGIN_TRUSTED_APP 4
+/*
+ * The message types.
+ */
+#define TF_MESSAGE_TYPE_CREATE_DEVICE_CONTEXT   0x02
+#define TF_MESSAGE_TYPE_DESTROY_DEVICE_CONTEXT  0xFD
+#define TF_MESSAGE_TYPE_REGISTER_SHARED_MEMORY  0xF7
+#define TF_MESSAGE_TYPE_RELEASE_SHARED_MEMORY   0xF9
+#define TF_MESSAGE_TYPE_OPEN_CLIENT_SESSION     0xF0
+#define TF_MESSAGE_TYPE_CLOSE_CLIENT_SESSION    0xF2
+#define TF_MESSAGE_TYPE_INVOKE_CLIENT_COMMAND   0xF5
+#define TF_MESSAGE_TYPE_CANCEL_CLIENT_COMMAND   0xF4
+#define TF_MESSAGE_TYPE_MANAGEMENT              0xFE
+
+
+/*
+ * The SChannel error codes.
+ */
+#define S_SUCCESS 0x00000000
+#define S_ERROR_OUT_OF_MEMORY 0xFFFF000C
+
+
+struct tf_command_header {
+        u8                       message_size;
+        u8                       message_type;
+        u16                      message_info;
+        u32                      operation_id;
+};
+
+struct tf_answer_header {
+        u8                   message_size;
+        u8                   message_type;
+        u16                  message_info;
+        u32                  operation_id;
+        u32                  error_code;
+};
+
+/*
+ * CREATE_DEVICE_CONTEXT command message.
+ */
+struct tf_command_create_device_context {
+        u8                       message_size;
+        u8                       message_type;
+        u16                      message_info_rfu;
+        u32                      operation_id;
+        u32                      device_context_id;
+};
+
+/*
+ * CREATE_DEVICE_CONTEXT answer message.
+ */
+struct tf_answer_create_device_context {
+        u8                       message_size;
+        u8                       message_type;
+        u16                      message_info_rfu;
+        /* an opaque Normal World identifier for the operation */
+        u32                      operation_id;
+        u32                      error_code;
+        /* an opaque Normal World identifier for the device context */
+        u32                      device_context;
+};
+
+/*
+ * DESTROY_DEVICE_CONTEXT command message.
+ */
+struct tf_command_destroy_device_context {
+        u8                       message_size;
+        u8                       message_type;
+        u16                      message_info_rfu;
+        u32                      operation_id;
+        u32                      device_context;
+};
+
+/*
+ * DESTROY_DEVICE_CONTEXT answer message.
+ */
+struct tf_answer_destroy_device_context {
+        u8                       message_size;
+        u8                       message_type;
+        u16                      message_info_rfu;
+        /* an opaque Normal World identifier for the operation */
+        u32                      operation_id;
+        u32                      error_code;
+        u32                      device_context_id;
+};
+
+/*
+ * OPEN_CLIENT_SESSION command message.
+ */
+struct tf_command_open_client_session {
+        u8                            message_size;
+        u8                            message_type;
+        u16                           param_types;
+        /* an opaque Normal World identifier for the operation */
+        u32                           operation_id;
+        u32                           device_context;
+        u32                           cancellation_id;
+        u64                           timeout;
+        struct tf_uuid                destination_uuid;
+        union tf_command_param        params[4];
+        u32                           login_type;
+        /*
+         * Size = 0 for public, [16] for group identification, [20] for
+         * authentication
+         */
+        u8                            login_data[20];
+};
+
+/*
+ * OPEN_CLIENT_SESSION answer message.
+ */
+struct tf_answer_open_client_session {
+        u8                       message_size;
+        u8                       message_type;
+        u8                       error_origin;
+        u8                       __reserved;
+        /* an opaque Normal World identifier for the operation */
+        u32                      operation_id;
+        u32                      error_code;
+        u32                      client_session;
+        union tf_answer_param    answers[4];
+};
+
+/*
+ * CLOSE_CLIENT_SESSION command message.
+ */
+struct tf_command_close_client_session {
+        u8                       message_size;
+        u8                       message_type;
+        u16                      message_info_rfu;
+        /* an opaque Normal World identifier for the operation */
+        u32                      operation_id;
+        u32                      device_context;
+        u32                      client_session;
+};
+
+/*
+ * CLOSE_CLIENT_SESSION answer message.
+ */
+struct tf_answer_close_client_session {
+        u8                       message_size;
+        u8                       message_type;
+        u16                      message_info_rfu;
+        /* an opaque Normal World identifier for the operation */
+        u32                      operation_id;
+        u32                      error_code;
+};
+
+
+/*
+ * REGISTER_SHARED_MEMORY command message
+ */
+struct tf_command_register_shared_memory {
+        u8  message_size;
+        u8  message_type;
+        u16 memory_flags;
+        u32 operation_id;
+        u32 device_context;
+        u32 block_id;
+        u32 shared_mem_size;
+        u32 shared_mem_start_offset;
+        u32 shared_mem_descriptors[TF_MAX_COARSE_PAGES];
+};
+
+/*
+ * REGISTER_SHARED_MEMORY answer message.
+ */
+struct tf_answer_register_shared_memory {
+        u8                       message_size;
+        u8                       message_type;
+        u16                      message_info_rfu;
+        /* an opaque Normal World identifier for the operation */
+        u32                      operation_id;
+        u32                      error_code;
+        u32                      block;
+};
+
+/*
+ * RELEASE_SHARED_MEMORY command message.
+ */
+struct tf_command_release_shared_memory {
+        u8                       message_size;
+        u8                       message_type;
+        u16                      message_info_rfu;
+        /* an opaque Normal World identifier for the operation */
+        u32                      operation_id;
+        u32                      device_context;
+        u32                      block;
+};
+
+/*
+ * RELEASE_SHARED_MEMORY answer message.
+ */
+struct tf_answer_release_shared_memory {
+        u8                       message_size;
+        u8                       message_type;
+        u16                      message_info_rfu;
+        u32                      operation_id;
+        u32                      error_code;
+        u32                      block_id;
+};
+
+/*
+ * INVOKE_CLIENT_COMMAND command message.
+ */
+struct tf_command_invoke_client_command {
+        u8                       message_size;
+        u8                       message_type;
+        u16                      param_types;
+        u32                      operation_id;
+        u32                      device_context;
+        u32                      client_session;
+        u64                      timeout;
+        u32                      cancellation_id;
+        u32                      client_command_identifier;
+        union tf_command_param   params[4];
+};
+
+/*
+ * INVOKE_CLIENT_COMMAND command answer.
+ */
+struct tf_answer_invoke_client_command {
+        u8                     message_size;
+        u8                     message_type;
+        u8                     error_origin;
+        u8                     __reserved;
+        u32                    operation_id;
+        u32                    error_code;
+        union tf_answer_param  answers[4];
+};
+
+/*
+ * CANCEL_CLIENT_OPERATION command message.
+ */
+struct tf_command_cancel_client_operation {
+        u8                   message_size;
+        u8                   message_type;
+        u16                  message_info_rfu;
+        /* an opaque Normal World identifier for the operation */
+        u32                  operation_id;
+        u32                  device_context;
+        u32                  client_session;
+        u32                  cancellation_id;
+};
+
+struct tf_answer_cancel_client_operation {
+        u8                   message_size;
+        u8                   message_type;
+        u16                  message_info_rfu;
+        u32                  operation_id;
+        u32                  error_code;
+};
+
+/*
+ * MANAGEMENT command message.
+ */
+struct tf_command_management {
+        u8                   message_size;
+        u8                   message_type;
+        u16                  command;
+        u32                  operation_id;
+        u32                  w3b_size;
+        u32                  w3b_start_offset;
+        u32                  shared_mem_descriptors[1];
+};
+
+/*
+ * POWER_MANAGEMENT answer message.
+ * The message does not provide message specific parameters.
+ * Therefore no need to define a specific answer structure
+ */
+
+/*
+ * Structure for L2 messages
+ */
+union tf_command {
+        struct tf_command_header                  header;
+        struct tf_command_create_device_context   create_device_context;
+        struct tf_command_destroy_device_context  destroy_device_context;
+        struct tf_command_open_client_session     open_client_session;
+        struct tf_command_close_client_session    close_client_session;
+        struct tf_command_register_shared_memory  register_shared_memory;
+        struct tf_command_release_shared_memory   release_shared_memory;
+        struct tf_command_invoke_client_command   invoke_client_command;
+        struct tf_command_cancel_client_operation cancel_client_operation;
+        struct tf_command_management              management;
+};
+
+/*
+ * Structure for any L2 answer
+ */
+
+union tf_answer {
+        struct tf_answer_header                  header;
+        struct tf_answer_create_device_context   create_device_context;
+        struct tf_answer_open_client_session     open_client_session;
+        struct tf_answer_close_client_session    close_client_session;
+        struct tf_answer_register_shared_memory  register_shared_memory;
+        struct tf_answer_release_shared_memory   release_shared_memory;
+        struct tf_answer_invoke_client_command   invoke_client_command;
+        struct tf_answer_destroy_device_context  destroy_device_context;
+        struct tf_answer_cancel_client_operation cancel_client_operation;
+};
+
+/* Structure of the Communication Buffer */
+struct tf_l1_shared_buffer {
+        #ifdef CONFIG_TF_ZEBRA
+        u32 exit_code;
+        u32 l1_shared_buffer_descr;
+        u32 backing_store_addr;
+        u32 backext_storage_addr;
+        u32 workspace_addr;
+        u32 workspace_size;
+        u32 conf_descriptor;
+        u32 conf_size;
+        u32 conf_offset;
+        u32 protocol_version;
+        u32 rpc_command;
+        u32 rpc_status;
+        u8  reserved1[16];
+        #else
+        u32 config_flag_s;
+        u32 w3b_size_max_s;
+        u32 reserved0;
+        u32 w3b_size_current_s;
+        u8  reserved1[48];
+        #endif
+        u8  version_description[TF_DESCRIPTION_BUFFER_LENGTH];
+        u32 status_s;
+        u32 reserved2;
+        u32 sync_serial_n;
+        u32 sync_serial_s;
+        u64 time_n[2];
+        u64 timeout_s[2];
+        u32 first_command;
+        u32 first_free_command;
+        u32 first_answer;
+        u32 first_free_answer;
+        u32 w3b_descriptors[128];
+        #ifdef CONFIG_TF_ZEBRA
+        u8  rpc_trace_buffer[140];
+        u8  rpc_cus_buffer[180];
+        #else
+        u8  reserved3[320];
+        #endif
+        u32 command_queue[TF_N_MESSAGE_QUEUE_CAPACITY];
+        u32 answer_queue[TF_S_ANSWER_QUEUE_CAPACITY];
+};
+
+
+/*
+ * tf_version_information_buffer structure description
+ * Description of the sVersionBuffer handed over from user space to kernel space
+ * This field is filled by the driver during a CREATE_DEVICE_CONTEXT ioctl
+ * and handed back to user space
+ */
+struct tf_version_information_buffer {
+        u8 driver_description[65];
+        u8 secure_world_description[65];
+};
+
+
+/* The IOCTLs the driver supports */
+#include <linux/ioctl.h>
+
+#define IOCTL_TF_GET_VERSION     _IO('z', 0)
+#define IOCTL_TF_EXCHANGE        _IOWR('z', 1, union tf_command)
+#define IOCTL_TF_GET_DESCRIPTION _IOR('z', 2, \
+        struct tf_version_information_buffer)
+
+#endif  /* !defined(__TF_PROTOCOL_H__) */
diff --git a/security/tf_driver/tf_util.c b/security/tf_driver/tf_util.c
new file mode 100644
index 00000000000..78f90bf677e
--- /dev/null
+++ b/security/tf_driver/tf_util.c
@@ -0,0 +1,1143 @@
+/**
+ * Copyright (c) 2011 Trusted Logic S.A.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#include <linux/mman.h>
+#include "tf_util.h"
+
+/*----------------------------------------------------------------------------
+ * Debug printing routines
+ *----------------------------------------------------------------------------*/
+#ifdef CONFIG_TF_DRIVER_DEBUG_SUPPORT
+
+void tf_trace_array(const char *fun, const char *msg,
+                    const void *ptr, size_t len)
+{
+        char hex[511];
+        bool ell = (len > sizeof(hex)/2);
+        unsigned lim = (len > sizeof(hex)/2 ? sizeof(hex)/2 : len);
+        unsigned i;
+        for (i = 0; i < lim; i++)
+                sprintf(hex + 2 * i, "%02x", ((unsigned char *)ptr)[i]);
+        pr_info("%s: %s[%u] = %s%s\n",
+                fun, msg, len, hex, ell ? "..." : "");
+}
+
+void address_cache_property(unsigned long va)
+{
+        unsigned long pa;
+        unsigned long inner;
+        unsigned long outer;
+
+        asm volatile ("mcr p15, 0, %0, c7, c8, 0" : : "r" (va));
+        asm volatile ("mrc p15, 0, %0, c7, c4, 0" : "=r" (pa));
+
+        dprintk(KERN_INFO "VA:%x, PA:%x\n",
+                (unsigned int) va,
+                (unsigned int) pa);
+
+        if (pa & 1) {
+                dprintk(KERN_INFO "Prop Error\n");
+                return;
+        }
+
+        outer = (pa >> 2) & 3;
+        dprintk(KERN_INFO "\touter : %x", (unsigned int) outer);
+
+        switch (outer) {
+        case 3:
+                dprintk(KERN_INFO "Write-Back, no Write-Allocate\n");
+                break;
+        case 2:
+                dprintk(KERN_INFO "Write-Through, no Write-Allocate.\n");
+                break;
+        case 1:
+                dprintk(KERN_INFO "Write-Back, Write-Allocate.\n");
+                break;
+        case 0:
+                dprintk(KERN_INFO "Non-cacheable.\n");
+                break;
+        }
+
+        inner = (pa >> 4) & 7;
+        dprintk(KERN_INFO "\tinner : %x", (unsigned int)inner);
+
+        switch (inner) {
+        case 7:
+                dprintk(KERN_INFO "Write-Back, no Write-Allocate\n");
+                break;
+        case 6:
+                dprintk(KERN_INFO "Write-Through.\n");
+                break;
+        case 5:
+                dprintk(KERN_INFO "Write-Back, Write-Allocate.\n");
+                break;
+        case 3:
+                dprintk(KERN_INFO "Device.\n");
+                break;
+        case 1:
+                dprintk(KERN_INFO "Strongly-ordered.\n");
+                break;
+        case 0:
+                dprintk(KERN_INFO "Non-cacheable.\n");
+                break;
+        }
+
+        if (pa & 0x00000002)
+                dprintk(KERN_INFO "SuperSection.\n");
+        if (pa & 0x00000080)
+                dprintk(KERN_INFO "Memory is shareable.\n");
+        else
+                dprintk(KERN_INFO "Memory is non-shareable.\n");
+
+        if (pa & 0x00000200)
+                dprintk(KERN_INFO "Non-secure.\n");
+}
+
+/*
+ * Dump the L1 shared buffer.
+ */
+void tf_dump_l1_shared_buffer(struct tf_l1_shared_buffer *buffer)
+{
+        dprintk(KERN_INFO
+                "buffer@%p:\n"
+                #ifndef CONFIG_TF_ZEBRA
+                "  config_flag_s=%08X\n"
+                #endif
+                "  version_description=%64s\n"
+                "  status_s=%08X\n"
+                "  sync_serial_n=%08X\n"
+                "  sync_serial_s=%08X\n"
+                "  time_n[0]=%016llX\n"
+                "  time_n[1]=%016llX\n"
+                "  timeout_s[0]=%016llX\n"
+                "  timeout_s[1]=%016llX\n"
+                "  first_command=%08X\n"
+                "  first_free_command=%08X\n"
+                "  first_answer=%08X\n"
+                "  first_free_answer=%08X\n\n",
+                buffer,
+                #ifndef CONFIG_TF_ZEBRA
+                buffer->config_flag_s,
+                #endif
+                buffer->version_description,
+                buffer->status_s,
+                buffer->sync_serial_n,
+                buffer->sync_serial_s,
+                buffer->time_n[0],
+                buffer->time_n[1],
+                buffer->timeout_s[0],
+                buffer->timeout_s[1],
+                buffer->first_command,
+                buffer->first_free_command,
+                buffer->first_answer,
+                buffer->first_free_answer);
+}
+
+
+/*
+ * Dump the specified SChannel message using dprintk.
+ */
+void tf_dump_command(union tf_command *command)
+{
+        u32 i;
+
+        dprintk(KERN_INFO "message@%p:\n", command);
+
+        switch (command->header.message_type) {
+        case TF_MESSAGE_TYPE_CREATE_DEVICE_CONTEXT:
+                dprintk(KERN_INFO
+                        "   message_size             = 0x%02X\n"
+                        "   message_type             = 0x%02X "
+                                "TF_MESSAGE_TYPE_CREATE_DEVICE_CONTEXT\n"
+                        "   operation_id             = 0x%08X\n"
+                        "   device_context_id         = 0x%08X\n",
+                        command->header.message_size,
+                        command->header.message_type,
+                        command->header.operation_id,
+                        command->create_device_context.device_context_id
+                );
+                break;
+
+        case TF_MESSAGE_TYPE_DESTROY_DEVICE_CONTEXT:
+                dprintk(KERN_INFO
+                        "   message_size    = 0x%02X\n"
+                        "   message_type    = 0x%02X "
+                                "TF_MESSAGE_TYPE_DESTROY_DEVICE_CONTEXT\n"
+                        "   operation_id    = 0x%08X\n"
+                        "   device_context  = 0x%08X\n",
+                        command->header.message_size,
+                        command->header.message_type,
+                        command->header.operation_id,
+                        command->destroy_device_context.device_context);
+                break;
+
+        case TF_MESSAGE_TYPE_OPEN_CLIENT_SESSION:
+                dprintk(KERN_INFO
+                        "   message_size                = 0x%02X\n"
+                        "   message_type                = 0x%02X "
+                                "TF_MESSAGE_TYPE_OPEN_CLIENT_SESSION\n"
+                        "   param_types                 = 0x%04X\n"
+                        "   operation_id                = 0x%08X\n"
+                        "   device_context              = 0x%08X\n"
+                        "   cancellation_id             = 0x%08X\n"
+                        "   timeout                    = 0x%016llX\n"
+                        "   destination_uuid            = "
+                                "%08X-%04X-%04X-%02X%02X-"
+                                "%02X%02X%02X%02X%02X%02X\n",
+                        command->header.message_size,
+                        command->header.message_type,
+                        command->open_client_session.param_types,
+                        command->header.operation_id,
+                        command->open_client_session.device_context,
+                        command->open_client_session.cancellation_id,
+                        command->open_client_session.timeout,
+                        command->open_client_session.destination_uuid.
+                                time_low,
+                        command->open_client_session.destination_uuid.
+                                time_mid,
+                        command->open_client_session.destination_uuid.
+                                time_hi_and_version,
+                        command->open_client_session.destination_uuid.
+                                clock_seq_and_node[0],
+                        command->open_client_session.destination_uuid.
+                                clock_seq_and_node[1],
+                        command->open_client_session.destination_uuid.
+                                clock_seq_and_node[2],
+                        command->open_client_session.destination_uuid.
+                                clock_seq_and_node[3],
+                        command->open_client_session.destination_uuid.
+                                clock_seq_and_node[4],
+                        command->open_client_session.destination_uuid.
+                                clock_seq_and_node[5],
+                        command->open_client_session.destination_uuid.
+                                clock_seq_and_node[6],
+                        command->open_client_session.destination_uuid.
+                                clock_seq_and_node[7]
+                );
+
+                for (i = 0; i < 4; i++) {
+                        uint32_t *param = (uint32_t *) &command->
+                                open_client_session.params[i];
+                        dprintk(KERN_INFO "   params[%d] = "
+                                "0x%08X:0x%08X:0x%08X\n",
+                                i, param[0], param[1], param[2]);
+                }
+
+                switch (TF_LOGIN_GET_MAIN_TYPE(
+                        command->open_client_session.login_type)) {
+                case TF_LOGIN_PUBLIC:
+                        dprintk(
+                                KERN_INFO "   login_type               = "
+                                        "TF_LOGIN_PUBLIC\n");
+                        break;
+                case TF_LOGIN_USER:
+                        dprintk(
+                                KERN_INFO "   login_type               = "
+                                        "TF_LOGIN_USER\n");
+                        break;
+                 case TF_LOGIN_GROUP:
+                        dprintk(
+                                KERN_INFO "   login_type               = "
+                                        "TF_LOGIN_GROUP\n");
+                        break;
+                case TF_LOGIN_APPLICATION:
+                        dprintk(
+                                KERN_INFO "   login_type               = "
+                                        "TF_LOGIN_APPLICATION\n");
+                        break;
+                case TF_LOGIN_APPLICATION_USER:
+                        dprintk(
+                                KERN_INFO "   login_type               = "
+                                        "TF_LOGIN_APPLICATION_USER\n");
+                        break;
+                case TF_LOGIN_APPLICATION_GROUP:
+                        dprintk(
+                                KERN_INFO "   login_type               = "
+                                        "TF_LOGIN_APPLICATION_GROUP\n");
+                        break;
+                case TF_LOGIN_AUTHENTICATION:
+                        dprintk(
+                                KERN_INFO "   login_type               = "
+                                        "TF_LOGIN_AUTHENTICATION\n");
+                        break;
+                case TF_LOGIN_PRIVILEGED:
+                        dprintk(
+                                KERN_INFO "   login_type               = "
+                                        "TF_LOGIN_PRIVILEGED\n");
+                        break;
+                case TF_LOGIN_PRIVILEGED_KERNEL:
+                        dprintk(
+                                KERN_INFO "   login_type               = "
+                                        "TF_LOGIN_PRIVILEGED_KERNEL\n");
+                        break;
+                default:
+                        dprintk(
+                                KERN_ERR "   login_type               = "
+                                        "0x%08X (Unknown login type)\n",
+                                command->open_client_session.login_type);
+                        break;
+                }
+
+                dprintk(
+                        KERN_INFO "   login_data               = ");
+                for (i = 0; i < 20; i++)
+                        dprintk(
+                                KERN_INFO "%d",
+                                command->open_client_session.
+                                        login_data[i]);
+                dprintk("\n");
+                break;
+
+        case TF_MESSAGE_TYPE_CLOSE_CLIENT_SESSION:
+                dprintk(KERN_INFO
+                        "   message_size                = 0x%02X\n"
+                        "   message_type                = 0x%02X "
+                                "TF_MESSAGE_TYPE_CLOSE_CLIENT_SESSION\n"
+                        "   operation_id                = 0x%08X\n"
+                        "   device_context              = 0x%08X\n"
+                        "   client_session              = 0x%08X\n",
+                        command->header.message_size,
+                        command->header.message_type,
+                        command->header.operation_id,
+                        command->close_client_session.device_context,
+                        command->close_client_session.client_session
+                );
+                break;
+
+        case TF_MESSAGE_TYPE_REGISTER_SHARED_MEMORY:
+                dprintk(KERN_INFO
+                        "   message_size             = 0x%02X\n"
+                        "   message_type             = 0x%02X "
+                                "TF_MESSAGE_TYPE_REGISTER_SHARED_MEMORY\n"
+                        "   memory_flags             = 0x%04X\n"
+                        "   operation_id             = 0x%08X\n"
+                        "   device_context           = 0x%08X\n"
+                        "   block_id                 = 0x%08X\n"
+                        "   shared_mem_size           = 0x%08X\n"
+                        "   shared_mem_start_offset    = 0x%08X\n"
+                        "   shared_mem_descriptors[0] = 0x%08X\n"
+                        "   shared_mem_descriptors[1] = 0x%08X\n"
+                        "   shared_mem_descriptors[2] = 0x%08X\n"
+                        "   shared_mem_descriptors[3] = 0x%08X\n"
+                        "   shared_mem_descriptors[4] = 0x%08X\n"
+                        "   shared_mem_descriptors[5] = 0x%08X\n"
+                        "   shared_mem_descriptors[6] = 0x%08X\n"
+                        "   shared_mem_descriptors[7] = 0x%08X\n",
+                        command->header.message_size,
+                        command->header.message_type,
+                        command->register_shared_memory.memory_flags,
+                        command->header.operation_id,
+                        command->register_shared_memory.device_context,
+                        command->register_shared_memory.block_id,
+                        command->register_shared_memory.shared_mem_size,
+                        command->register_shared_memory.
+                                shared_mem_start_offset,
+                        command->register_shared_memory.
+                                shared_mem_descriptors[0],
+                        command->register_shared_memory.
+                                shared_mem_descriptors[1],
+                        command->register_shared_memory.
+                                shared_mem_descriptors[2],
+                        command->register_shared_memory.
+                                shared_mem_descriptors[3],
+                        command->register_shared_memory.
+                                shared_mem_descriptors[4],
+                        command->register_shared_memory.
+                                shared_mem_descriptors[5],
+                        command->register_shared_memory.
+                                shared_mem_descriptors[6],
+                        command->register_shared_memory.
+                                shared_mem_descriptors[7]);
+                break;
+
+        case TF_MESSAGE_TYPE_RELEASE_SHARED_MEMORY:
+                dprintk(KERN_INFO
+                        "   message_size    = 0x%02X\n"
+                        "   message_type    = 0x%02X "
+                                "TF_MESSAGE_TYPE_RELEASE_SHARED_MEMORY\n"
+                        "   operation_id    = 0x%08X\n"
+                        "   device_context  = 0x%08X\n"
+                        "   block          = 0x%08X\n",
+                        command->header.message_size,
+                        command->header.message_type,
+                        command->header.operation_id,
+                        command->release_shared_memory.device_context,
+                        command->release_shared_memory.block);
+                break;
+
+        case TF_MESSAGE_TYPE_INVOKE_CLIENT_COMMAND:
+                dprintk(KERN_INFO
+                         "   message_size                = 0x%02X\n"
+                        "   message_type                = 0x%02X "
+                                "TF_MESSAGE_TYPE_INVOKE_CLIENT_COMMAND\n"
+                        "   param_types                 = 0x%04X\n"
+                        "   operation_id                = 0x%08X\n"
+                        "   device_context              = 0x%08X\n"
+                        "   client_session              = 0x%08X\n"
+                        "   timeout                    = 0x%016llX\n"
+                        "   cancellation_id             = 0x%08X\n"
+                        "   client_command_identifier    = 0x%08X\n",
+                        command->header.message_size,
+                        command->header.message_type,
+                        command->invoke_client_command.param_types,
+                        command->header.operation_id,
+                        command->invoke_client_command.device_context,
+                        command->invoke_client_command.client_session,
+                        command->invoke_client_command.timeout,
+                        command->invoke_client_command.cancellation_id,
+                        command->invoke_client_command.
+                                client_command_identifier
+                );
+
+                for (i = 0; i < 4; i++) {
+                        uint32_t *param = (uint32_t *) &command->
+                                open_client_session.params[i];
+                        dprintk(KERN_INFO "   params[%d] = "
+                                "0x%08X:0x%08X:0x%08X\n", i,
+                                param[0], param[1], param[2]);
+                }
+                break;
+
+        case TF_MESSAGE_TYPE_CANCEL_CLIENT_COMMAND:
+                dprintk(KERN_INFO
+                        "   message_size       = 0x%02X\n"
+                        "   message_type       = 0x%02X "
+                                "TF_MESSAGE_TYPE_CANCEL_CLIENT_COMMAND\n"
+                        "   operation_id       = 0x%08X\n"
+                        "   device_context     = 0x%08X\n"
+                        "   client_session     = 0x%08X\n",
+                        command->header.message_size,
+                        command->header.message_type,
+                        command->header.operation_id,
+                        command->cancel_client_operation.device_context,
+                        command->cancel_client_operation.client_session);
+                break;
+
+        case TF_MESSAGE_TYPE_MANAGEMENT:
+                dprintk(KERN_INFO
+                        "   message_size             = 0x%02X\n"
+                        "   message_type             = 0x%02X "
+                                "TF_MESSAGE_TYPE_MANAGEMENT\n"
+                        "   operation_id             = 0x%08X\n"
+                        "   command                 = 0x%08X\n"
+                        "   w3b_size                 = 0x%08X\n"
+                        "   w3b_start_offset          = 0x%08X\n",
+                        command->header.message_size,
+                        command->header.message_type,
+                        command->header.operation_id,
+                        command->management.command,
+                        command->management.w3b_size,
+                        command->management.w3b_start_offset);
+                break;
+
+        default:
+                dprintk(
+                        KERN_ERR "   message_type = 0x%08X "
+                                "(Unknown message type)\n",
+                        command->header.message_type);
+                break;
+        }
+}
+
+
+/*
+ * Dump the specified SChannel answer using dprintk.
+ */
+void tf_dump_answer(union tf_answer *answer)
+{
+        u32 i;
+        dprintk(
+                KERN_INFO "answer@%p:\n",
+                answer);
+
+        switch (answer->header.message_type) {
+        case TF_MESSAGE_TYPE_CREATE_DEVICE_CONTEXT:
+                dprintk(KERN_INFO
+                        "   message_size    = 0x%02X\n"
+                        "   message_type    = 0x%02X "
+                                "tf_answer_create_device_context\n"
+                        "   operation_id    = 0x%08X\n"
+                        "   error_code      = 0x%08X\n"
+                        "   device_context  = 0x%08X\n",
+                        answer->header.message_size,
+                        answer->header.message_type,
+                        answer->header.operation_id,
+                        answer->create_device_context.error_code,
+                        answer->create_device_context.device_context);
+                break;
+
+        case TF_MESSAGE_TYPE_DESTROY_DEVICE_CONTEXT:
+                dprintk(KERN_INFO
+                        "   message_size     = 0x%02X\n"
+                        "   message_type     = 0x%02X "
+                                "ANSWER_DESTROY_DEVICE_CONTEXT\n"
+                        "   operation_id     = 0x%08X\n"
+                        "   error_code       = 0x%08X\n"
+                        "   device_context_id = 0x%08X\n",
+                        answer->header.message_size,
+                        answer->header.message_type,
+                        answer->header.operation_id,
+                        answer->destroy_device_context.error_code,
+                        answer->destroy_device_context.device_context_id);
+                break;
+
+
+        case TF_MESSAGE_TYPE_OPEN_CLIENT_SESSION:
+                dprintk(KERN_INFO
+                        "   message_size      = 0x%02X\n"
+                        "   message_type      = 0x%02X "
+                                "tf_answer_open_client_session\n"
+                        "   error_origin     = 0x%02X\n"
+                        "   operation_id      = 0x%08X\n"
+                        "   error_code        = 0x%08X\n"
+                        "   client_session    = 0x%08X\n",
+                        answer->header.message_size,
+                        answer->header.message_type,
+                        answer->open_client_session.error_origin,
+                        answer->header.operation_id,
+                        answer->open_client_session.error_code,
+                        answer->open_client_session.client_session);
+                for (i = 0; i < 4; i++) {
+                        dprintk(KERN_INFO "   answers[%d]=0x%08X:0x%08X\n",
+                                i,
+                                answer->open_client_session.answers[i].
+                                        value.a,
+                                answer->open_client_session.answers[i].
+                                        value.b);
+                }
+                break;
+
+        case TF_MESSAGE_TYPE_CLOSE_CLIENT_SESSION:
+                dprintk(KERN_INFO
+                        "   message_size      = 0x%02X\n"
+                        "   message_type      = 0x%02X "
+                                "ANSWER_CLOSE_CLIENT_SESSION\n"
+                        "   operation_id      = 0x%08X\n"
+                        "   error_code        = 0x%08X\n",
+                        answer->header.message_size,
+                        answer->header.message_type,
+                        answer->header.operation_id,
+                        answer->close_client_session.error_code);
+                break;
+
+        case TF_MESSAGE_TYPE_REGISTER_SHARED_MEMORY:
+                dprintk(KERN_INFO
+                        "   message_size    = 0x%02X\n"
+                        "   message_type    = 0x%02X "
+                                "tf_answer_register_shared_memory\n"
+                        "   operation_id    = 0x%08X\n"
+                        "   error_code      = 0x%08X\n"
+                        "   block          = 0x%08X\n",
+                        answer->header.message_size,
+                        answer->header.message_type,
+                        answer->header.operation_id,
+                        answer->register_shared_memory.error_code,
+                        answer->register_shared_memory.block);
+                break;
+
+        case TF_MESSAGE_TYPE_RELEASE_SHARED_MEMORY:
+                dprintk(KERN_INFO
+                        "   message_size    = 0x%02X\n"
+                        "   message_type    = 0x%02X "
+                                "ANSWER_RELEASE_SHARED_MEMORY\n"
+                        "   operation_id    = 0x%08X\n"
+                        "   error_code      = 0x%08X\n"
+                        "   block_id        = 0x%08X\n",
+                        answer->header.message_size,
+                        answer->header.message_type,
+                        answer->header.operation_id,
+                        answer->release_shared_memory.error_code,
+                        answer->release_shared_memory.block_id);
+                break;
+
+        case TF_MESSAGE_TYPE_INVOKE_CLIENT_COMMAND:
+                dprintk(KERN_INFO
+                        "   message_size      = 0x%02X\n"
+                        "   message_type      = 0x%02X "
+                                "tf_answer_invoke_client_command\n"
+                        "   error_origin     = 0x%02X\n"
+                        "   operation_id      = 0x%08X\n"
+                        "   error_code        = 0x%08X\n",
+                        answer->header.message_size,
+                        answer->header.message_type,
+                        answer->invoke_client_command.error_origin,
+                        answer->header.operation_id,
+                        answer->invoke_client_command.error_code
+                        );
+                for (i = 0; i < 4; i++) {
+                        dprintk(KERN_INFO "   answers[%d]=0x%08X:0x%08X\n",
+                                i,
+                                answer->invoke_client_command.answers[i].
+                                        value.a,
+                                answer->invoke_client_command.answers[i].
+                                        value.b);
+                }
+                break;
+
+        case TF_MESSAGE_TYPE_CANCEL_CLIENT_COMMAND:
+                dprintk(KERN_INFO
+                        "   message_size      = 0x%02X\n"
+                        "   message_type      = 0x%02X "
+                                "TF_ANSWER_CANCEL_CLIENT_COMMAND\n"
+                        "   operation_id      = 0x%08X\n"
+                        "   error_code        = 0x%08X\n",
+                        answer->header.message_size,
+                        answer->header.message_type,
+                        answer->header.operation_id,
+                        answer->cancel_client_operation.error_code);
+                break;
+
+        case TF_MESSAGE_TYPE_MANAGEMENT:
+                dprintk(KERN_INFO
+                        "   message_size      = 0x%02X\n"
+                        "   message_type      = 0x%02X "
+                                "TF_MESSAGE_TYPE_MANAGEMENT\n"
+                        "   operation_id      = 0x%08X\n"
+                        "   error_code        = 0x%08X\n",
+                        answer->header.message_size,
+                        answer->header.message_type,
+                        answer->header.operation_id,
+                        answer->header.error_code);
+                break;
+
+        default:
+                dprintk(
+                        KERN_ERR "   message_type = 0x%02X "
+                                "(Unknown message type)\n",
+                        answer->header.message_type);
+                break;
+
+        }
+}
+
+#endif  /* defined(TF_DRIVER_DEBUG_SUPPORT) */
+
+/*----------------------------------------------------------------------------
+ * SHA-1 implementation
+ * This is taken from the Linux kernel source crypto/sha1.c
+ *----------------------------------------------------------------------------*/
+
+struct sha1_ctx {
+        u64 count;
+        u32 state[5];
+        u8 buffer[64];
+};
+
+static inline u32 rol(u32 value, u32 bits)
+{
+        return ((value) << (bits)) | ((value) >> (32 - (bits)));
+}
+
+/* blk0() and blk() perform the initial expand. */
+/* I got the idea of expanding during the round function from SSLeay */
+#define blk0(i) block32[i]
+
+#define blk(i) (block32[i & 15] = rol( \
+        block32[(i + 13) & 15] ^ block32[(i + 8) & 15] ^ \
+        block32[(i + 2) & 15] ^ block32[i & 15], 1))
+
+/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
+#define R0(v, w, x, y, z, i) do { \
+        z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \
+        w = rol(w, 30); } while (0)
+
+#define R1(v, w, x, y, z, i) do { \
+        z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \
+        w = rol(w, 30); } while (0)
+
+#define R2(v, w, x, y, z, i) do { \
+        z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \
+        w = rol(w, 30); } while (0)
+
+#define R3(v, w, x, y, z, i) do { \
+        z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \
+        w = rol(w, 30); } while (0)
+
+#define R4(v, w, x, y, z, i) do { \
+        z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \
+        w = rol(w, 30); } while (0)
+
+
+/* Hash a single 512-bit block. This is the core of the algorithm. */
+static void sha1_transform(u32 *state, const u8 *in)
+{
+        u32 a, b, c, d, e;
+        u32 block32[16];
+
+        /* convert/copy data to workspace */
+        for (a = 0; a < sizeof(block32)/sizeof(u32); a++)
+                block32[a] = ((u32) in[4 * a]) << 24 |
+                             ((u32) in[4 * a + 1]) << 16 |
+                             ((u32) in[4 * a + 2]) <<  8 |
+                             ((u32) in[4 * a + 3]);
+
+        /* Copy context->state[] to working vars */
+        a = state[0];
+        b = state[1];
+        c = state[2];
+        d = state[3];
+        e = state[4];
+
+        /* 4 rounds of 20 operations each. Loop unrolled. */
+        R0(a, b, c, d, e, 0); R0(e, a, b, c, d, 1);
+        R0(d, e, a, b, c, 2); R0(c, d, e, a, b, 3);
+        R0(b, c, d, e, a, 4); R0(a, b, c, d, e, 5);
+        R0(e, a, b, c, d, 6); R0(d, e, a, b, c, 7);
+        R0(c, d, e, a, b, 8); R0(b, c, d, e, a, 9);
+        R0(a, b, c, d, e, 10); R0(e, a, b, c, d, 11);
+        R0(d, e, a, b, c, 12); R0(c, d, e, a, b, 13);
+        R0(b, c, d, e, a, 14); R0(a, b, c, d, e, 15);
+
+        R1(e, a, b, c, d, 16); R1(d, e, a, b, c, 17);
+        R1(c, d, e, a, b, 18); R1(b, c, d, e, a, 19);
+
+        R2(a, b, c, d, e, 20); R2(e, a, b, c, d, 21);
+        R2(d, e, a, b, c, 22); R2(c, d, e, a, b, 23);
+        R2(b, c, d, e, a, 24); R2(a, b, c, d, e, 25);
+        R2(e, a, b, c, d, 26); R2(d, e, a, b, c, 27);
+        R2(c, d, e, a, b, 28); R2(b, c, d, e, a, 29);
+        R2(a, b, c, d, e, 30); R2(e, a, b, c, d, 31);
+        R2(d, e, a, b, c, 32); R2(c, d, e, a, b, 33);
+        R2(b, c, d, e, a, 34); R2(a, b, c, d, e, 35);
+        R2(e, a, b, c, d, 36); R2(d, e, a, b, c, 37);
+        R2(c, d, e, a, b, 38); R2(b, c, d, e, a, 39);
+
+        R3(a, b, c, d, e, 40); R3(e, a, b, c, d, 41);
+        R3(d, e, a, b, c, 42); R3(c, d, e, a, b, 43);
+        R3(b, c, d, e, a, 44); R3(a, b, c, d, e, 45);
+        R3(e, a, b, c, d, 46); R3(d, e, a, b, c, 47);
+        R3(c, d, e, a, b, 48); R3(b, c, d, e, a, 49);
+        R3(a, b, c, d, e, 50); R3(e, a, b, c, d, 51);
+        R3(d, e, a, b, c, 52); R3(c, d, e, a, b, 53);
+        R3(b, c, d, e, a, 54); R3(a, b, c, d, e, 55);
+        R3(e, a, b, c, d, 56); R3(d, e, a, b, c, 57);
+        R3(c, d, e, a, b, 58); R3(b, c, d, e, a, 59);
+
+        R4(a, b, c, d, e, 60); R4(e, a, b, c, d, 61);
+        R4(d, e, a, b, c, 62); R4(c, d, e, a, b, 63);
+        R4(b, c, d, e, a, 64); R4(a, b, c, d, e, 65);
+        R4(e, a, b, c, d, 66); R4(d, e, a, b, c, 67);
+        R4(c, d, e, a, b, 68); R4(b, c, d, e, a, 69);
+        R4(a, b, c, d, e, 70); R4(e, a, b, c, d, 71);
+        R4(d, e, a, b, c, 72); R4(c, d, e, a, b, 73);
+        R4(b, c, d, e, a, 74); R4(a, b, c, d, e, 75);
+        R4(e, a, b, c, d, 76); R4(d, e, a, b, c, 77);
+        R4(c, d, e, a, b, 78); R4(b, c, d, e, a, 79);
+
+        /* Add the working vars back into context.state[] */
+        state[0] += a;
+        state[1] += b;
+        state[2] += c;
+        state[3] += d;
+        state[4] += e;
+        /* Wipe variables */
+        a = b = c = d = e = 0;
+        memset(block32, 0x00, sizeof(block32));
+}
+
+
+static void sha1_init(void *ctx)
+{
+        struct sha1_ctx *sctx = ctx;
+        static const struct sha1_ctx initstate = {
+                0,
+                { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 },
+                { 0, }
+        };
+
+        *sctx = initstate;
+}
+
+
+static void sha1_update(void *ctx, const u8 *data, unsigned int len)
+{
+        struct sha1_ctx *sctx = ctx;
+        unsigned int i, j;
+
+        j = (sctx->count >> 3) & 0x3f;
+        sctx->count += len << 3;
+
+        if ((j + len) > 63) {
+                memcpy(&sctx->buffer[j], data, (i = 64 - j));
+                sha1_transform(sctx->state, sctx->buffer);
+                for ( ; i + 63 < len; i += 64)
+                        sha1_transform(sctx->state, &data[i]);
+                j = 0;
+        } else
+                i = 0;
+        memcpy(&sctx->buffer[j], &data[i], len - i);
+}
+
+
+/* Add padding and return the message digest. */
+static void sha1_final(void *ctx, u8 *out)
+{
+        struct sha1_ctx *sctx = ctx;
+        u32 i, j, index, padlen;
+        u64 t;
+        u8 bits[8] = { 0, };
+        static const u8 padding[64] = { 0x80, };
+
+        t = sctx->count;
+        bits[7] = 0xff & t; t >>= 8;
+        bits[6] = 0xff & t; t >>= 8;
+        bits[5] = 0xff & t; t >>= 8;
+        bits[4] = 0xff & t; t >>= 8;
+        bits[3] = 0xff & t; t >>= 8;
+        bits[2] = 0xff & t; t >>= 8;
+        bits[1] = 0xff & t; t >>= 8;
+        bits[0] = 0xff & t;
+
+        /* Pad out to 56 mod 64 */
+        index = (sctx->count >> 3) & 0x3f;
+        padlen = (index < 56) ? (56 - index) : ((64+56) - index);
+        sha1_update(sctx, padding, padlen);
+
+        /* Append length */
+        sha1_update(sctx, bits, sizeof(bits));
+
+        /* Store state in digest */
+        for (i = j = 0; i < 5; i++, j += 4) {
+                u32 t2 = sctx->state[i];
+                out[j+3] = t2 & 0xff; t2 >>= 8;
+                out[j+2] = t2 & 0xff; t2 >>= 8;
+                out[j+1] = t2 & 0xff; t2 >>= 8;
+                out[j] = t2 & 0xff;
+        }
+
+        /* Wipe context */
+        memset(sctx, 0, sizeof(*sctx));
+}
+
+
+
+
+/*----------------------------------------------------------------------------
+ * Process identification
+ *----------------------------------------------------------------------------*/
+
+/* This function generates a processes hash table for authentication */
+int tf_get_current_process_hash(void *hash)
+{
+        int result = 0;
+        void *buffer;
+        struct mm_struct *mm;
+        struct vm_area_struct *vma;
+
+        buffer = internal_kmalloc(PAGE_SIZE, GFP_KERNEL);
+        if (buffer == NULL) {
+                dprintk(
+                        KERN_ERR "tf_get_current_process_hash:"
+                        " Out of memory for buffer!\n");
+                return -ENOMEM;
+        }
+
+        mm = current->mm;
+
+        down_read(&(mm->mmap_sem));
+        for (vma = mm->mmap; vma != NULL; vma = vma->vm_next) {
+                if ((vma->vm_flags & VM_EXECUTABLE) != 0 && vma->vm_file
+                                != NULL) {
+                        struct dentry *dentry;
+                        unsigned long start;
+                        unsigned long cur;
+                        unsigned long end;
+                        struct sha1_ctx sha1;
+
+                        dentry = dget(vma->vm_file->f_dentry);
+
+                        dprintk(
+                                KERN_DEBUG "tf_get_current_process_hash: "
+                                        "Found executable VMA for inode %lu "
+                                        "(%lu bytes).\n",
+                                        dentry->d_inode->i_ino,
+                                        (unsigned long) (dentry->d_inode->
+                                                i_size));
+
+                        start = do_mmap(vma->vm_file, 0,
+                                dentry->d_inode->i_size,
+                                PROT_READ | PROT_WRITE | PROT_EXEC,
+                                MAP_PRIVATE, 0);
+                        if (start < 0) {
+                                dprintk(
+                                        KERN_ERR "tf_get_current_process_hash"
+                                        "Hash: do_mmap failed (error %d)!\n",
+                                        (int) start);
+                                dput(dentry);
+                                result = -EFAULT;
+                                goto vma_out;
+                        }
+
+                        end = start + dentry->d_inode->i_size;
+
+                        sha1_init(&sha1);
+                        cur = start;
+                        while (cur < end) {
+                                unsigned long chunk;
+
+                                chunk = end - cur;
+                                if (chunk > PAGE_SIZE)
+                                        chunk = PAGE_SIZE;
+                                if (copy_from_user(buffer, (const void *) cur,
+                                                chunk) != 0) {
+                                        dprintk(
+                                                KERN_ERR "tf_get_current_"
+                                                "process_hash: copy_from_user "
+                                                "failed!\n");
+                                        result = -EINVAL;
+                                        (void) do_munmap(mm, start,
+                                                dentry->d_inode->i_size);
+                                        dput(dentry);
+                                        goto vma_out;
+                                }
+                                sha1_update(&sha1, buffer, chunk);
+                                cur += chunk;
+                        }
+                        sha1_final(&sha1, hash);
+                        result = 0;
+
+                        (void) do_munmap(mm, start, dentry->d_inode->i_size);
+                        dput(dentry);
+                        break;
+                }
+        }
+vma_out:
+        up_read(&(mm->mmap_sem));
+
+        internal_kfree(buffer);
+
+        if (result == -ENOENT)
+                dprintk(
+                        KERN_ERR "tf_get_current_process_hash: "
+                                "No executable VMA found for process!\n");
+        return result;
+}
+
+#ifndef CONFIG_ANDROID
+/* This function hashes the path of the current application.
+ * If data = NULL ,nothing else is added to the hash
+                else add data to the hash
+  */
+int tf_hash_application_path_and_data(char *buffer, void *data,
+        u32 data_len)
+{
+        int result = -ENOENT;
+        char *tmp = NULL;
+        struct mm_struct *mm;
+        struct vm_area_struct *vma;
+
+        tmp = internal_kmalloc(PAGE_SIZE, GFP_KERNEL);
+        if (tmp == NULL) {
+                result = -ENOMEM;
+                goto end;
+        }
+
+        mm = current->mm;
+
+        down_read(&(mm->mmap_sem));
+        for (vma = mm->mmap; vma != NULL; vma = vma->vm_next) {
+                if ((vma->vm_flags & VM_EXECUTABLE) != 0
+                                && vma->vm_file != NULL) {
+                        struct path *path;
+                        char *endpath;
+                        size_t pathlen;
+                        struct sha1_ctx sha1;
+                        u8 hash[SHA1_DIGEST_SIZE];
+
+                        path = &vma->vm_file->f_path;
+
+                        endpath = d_path(path, tmp, PAGE_SIZE);
+                        if (IS_ERR(path)) {
+                                result = PTR_ERR(endpath);
+                                up_read(&(mm->mmap_sem));
+                                goto end;
+                        }
+                        pathlen = (tmp + PAGE_SIZE) - endpath;
+
+#ifdef CONFIG_TF_DRIVER_DEBUG_SUPPORT
+                        {
+                                char *c;
+                                dprintk(KERN_DEBUG "current process path = ");
+                                for (c = endpath;
+                                     c < tmp + PAGE_SIZE;
+                                     c++)
+                                        dprintk("%c", *c);
+
+                                dprintk(", uid=%d, euid=%d\n", current_uid(),
+                                        current_euid());
+                        }
+#endif /* defined(CONFIG_TF_DRIVER_DEBUG_SUPPORT) */
+
+                        sha1_init(&sha1);
+                        sha1_update(&sha1, endpath, pathlen);
+                        if (data != NULL) {
+                                dprintk(KERN_INFO "current process path: "
+                                        "Hashing additional data\n");
+                                sha1_update(&sha1, data, data_len);
+                        }
+                        sha1_final(&sha1, hash);
+                        memcpy(buffer, hash, sizeof(hash));
+
+                        result = 0;
+
+                        break;
+                }
+        }
+        up_read(&(mm->mmap_sem));
+
+end:
+        if (tmp != NULL)
+                internal_kfree(tmp);
+
+        return result;
+}
+#endif /* !CONFIG_ANDROID */
+
+void *internal_kmalloc(size_t size, int priority)
+{
+        void *ptr;
+        struct tf_device *dev = tf_get_device();
+
+        ptr = kmalloc(size, priority);
+
+        if (ptr != NULL)
+                atomic_inc(
+                        &dev->stats.stat_memories_allocated);
+
+        return ptr;
+}
+
+void internal_kfree(void *ptr)
+{
+        struct tf_device *dev = tf_get_device();
+
+        if (ptr != NULL)
+                atomic_dec(
+                        &dev->stats.stat_memories_allocated);
+        return kfree(ptr);
+}
+
+void internal_vunmap(void *ptr)
+{
+        struct tf_device *dev = tf_get_device();
+
+        if (ptr != NULL)
+                atomic_dec(
+                        &dev->stats.stat_memories_allocated);
+
+        vunmap((void *) (((unsigned int)ptr) & 0xFFFFF000));
+}
+
+void *internal_vmalloc(size_t size)
+{
+        void *ptr;
+        struct tf_device *dev = tf_get_device();
+
+        ptr = vmalloc(size);
+
+        if (ptr != NULL)
+                atomic_inc(
+                        &dev->stats.stat_memories_allocated);
+
+        return ptr;
+}
+
+void internal_vfree(void *ptr)
+{
+        struct tf_device *dev = tf_get_device();
+
+        if (ptr != NULL)
+                atomic_dec(
+                        &dev->stats.stat_memories_allocated);
+        return vfree(ptr);
+}
+
+unsigned long internal_get_zeroed_page(int priority)
+{
+        unsigned long result;
+        struct tf_device *dev = tf_get_device();
+
+        result = get_zeroed_page(priority);
+
+        if (result != 0)
+                atomic_inc(&dev->stats.
+                                stat_pages_allocated);
+
+        return result;
+}
+
+void internal_free_page(unsigned long addr)
+{
+        struct tf_device *dev = tf_get_device();
+
+        if (addr != 0)
+                atomic_dec(
+                        &dev->stats.stat_pages_allocated);
+        return free_page(addr);
+}
+
+int internal_get_user_pages(
+                struct task_struct *tsk,
+                struct mm_struct *mm,
+                unsigned long start,
+                int len,
+                int write,
+                int force,
+                struct page **pages,
+                struct vm_area_struct **vmas)
+{
+        int result;
+        struct tf_device *dev = tf_get_device();
+
+        result = get_user_pages(
+                tsk,
+                mm,
+                start,
+                len,
+                write,
+                force,
+                pages,
+                vmas);
+
+        if (result > 0)
+                atomic_add(result,
+                        &dev->stats.stat_pages_locked);
+
+        return result;
+}
+
+void internal_get_page(struct page *page)
+{
+        struct tf_device *dev = tf_get_device();
+
+        atomic_inc(&dev->stats.stat_pages_locked);
+
+        get_page(page);
+}
+
+void internal_page_cache_release(struct page *page)
+{
+        struct tf_device *dev = tf_get_device();
+
+        atomic_dec(&dev->stats.stat_pages_locked);
+
+        page_cache_release(page);
+}
+
+
diff --git a/security/tf_driver/tf_util.h b/security/tf_driver/tf_util.h
new file mode 100644
index 00000000000..14bc78952d8
--- /dev/null
+++ b/security/tf_driver/tf_util.h
@@ -0,0 +1,122 @@
+/**
+ * Copyright (c) 2011 Trusted Logic S.A.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+#ifndef __TF_UTIL_H__
+#define __TF_UTIL_H__
+
+#include <linux/spinlock.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/mm.h>
+#include <linux/crypto.h>
+#include <linux/mount.h>
+#include <linux/pagemap.h>
+#include <linux/vmalloc.h>
+#include <asm/byteorder.h>
+
+#include "tf_protocol.h"
+#include "tf_defs.h"
+
+/*----------------------------------------------------------------------------
+ * Debug printing routines
+ *----------------------------------------------------------------------------*/
+
+#ifdef CONFIG_TF_DRIVER_DEBUG_SUPPORT
+extern unsigned tf_debug_level;
+
+void address_cache_property(unsigned long va);
+
+#define dprintk(args...) ((void)(tf_debug_level >= 6 ? printk(args) : 0))
+#define dpr_info(args...) ((void)(tf_debug_level >= 3 ? pr_info(args) : 0))
+#define dpr_err(args...) ((void)(tf_debug_level >= 1 ? pr_err(args) : 0))
+#define INFO(fmt, args...) \
+        (void)dprintk(KERN_INFO "%s: " fmt "\n", __func__, ## args)
+#define WARNING(fmt, args...)  \
+        (tf_debug_level >= 3 ?                                          \
+         printk(KERN_WARNING "%s: " fmt "\n", __func__, ## args) :      \
+         (void)0)
+#define ERROR(fmt, args...) \
+        (tf_debug_level >= 1 ?                                          \
+         printk(KERN_ERR "%s: " fmt "\n", __func__, ## args) :  \
+         (void)0)
+void tf_trace_array(const char *fun, const char *msg,
+                    const void *ptr, size_t len);
+#define TF_TRACE_ARRAY(ptr, len) \
+        (tf_debug_level >= 7 ? \
+         tf_trace_array(__func__, #ptr "/" #len, ptr, len) : \
+         0)
+
+void tf_dump_l1_shared_buffer(struct tf_l1_shared_buffer *buffer);
+
+void tf_dump_command(union tf_command *command);
+
+void tf_dump_answer(union tf_answer *answer);
+
+#else /* defined(CONFIG_TF_DRIVER_DEBUG_SUPPORT) */
+
+#define dprintk(args...)  do { ; } while (0)
+#define dpr_info(args...)  do { ; } while (0)
+#define dpr_err(args...)  do { ; } while (0)
+#define INFO(fmt, args...) ((void)0)
+#define WARNING(fmt, args...) ((void)0)
+#define ERROR(fmt, args...) ((void)0)
+#define TF_TRACE_ARRAY(ptr, len) ((void)(ptr), (void)(len))
+#define tf_dump_l1_shared_buffer(buffer)  ((void) 0)
+#define tf_dump_command(command)  ((void) 0)
+#define tf_dump_answer(answer)  ((void) 0)
+
+#endif /* defined(CONFIG_TF_DRIVER_DEBUG_SUPPORT) */
+
+#define SHA1_DIGEST_SIZE        20
+
+/*----------------------------------------------------------------------------
+ * Process identification
+ *----------------------------------------------------------------------------*/
+
+int tf_get_current_process_hash(void *hash);
+
+#ifndef CONFIG_ANDROID
+int tf_hash_application_path_and_data(char *buffer, void *data, u32 data_len);
+#endif /* !CONFIG_ANDROID */
+
+/*----------------------------------------------------------------------------
+ * Statistic computation
+ *----------------------------------------------------------------------------*/
+
+void *internal_kmalloc(size_t size, int priority);
+void internal_kfree(void *ptr);
+void internal_vunmap(void *ptr);
+void *internal_vmalloc(size_t size);
+void internal_vfree(void *ptr);
+unsigned long internal_get_zeroed_page(int priority);
+void internal_free_page(unsigned long addr);
+int internal_get_user_pages(
+                struct task_struct *tsk,
+                struct mm_struct *mm,
+                unsigned long start,
+                int len,
+                int write,
+                int force,
+                struct page **pages,
+                struct vm_area_struct **vmas);
+void internal_get_page(struct page *page);
+void internal_page_cache_release(struct page *page);
+#endif  /* __TF_UTIL_H__ */
+
diff --git a/security/tomoyo/.gitignore b/security/tomoyo/.gitignore
new file mode 100644
index 00000000000..5caf1a6f590
--- /dev/null
+++ b/security/tomoyo/.gitignore
@@ -0,0 +1,2 @@
+builtin-policy.h
+policy/
diff --git a/security/tomoyo/Kconfig b/security/tomoyo/Kconfig
index c8f38579323..7c7f8c16c10 100644
--- a/security/tomoyo/Kconfig
+++ b/security/tomoyo/Kconfig
@@ -9,3 +9,64 @@ config SECURITY_TOMOYO
           Required userspace tools and further information may be
           found at <http://tomoyo.sourceforge.jp/>.
           If you are unsure how to answer this question, answer N.
+
+config SECURITY_TOMOYO_MAX_ACCEPT_ENTRY
+        int "Default maximal count for learning mode"
+        default 2048
+        range 0 2147483647
+        depends on SECURITY_TOMOYO
+        help
+          This is the default value for maximal ACL entries
+          that are automatically appended into policy at "learning mode".
+          Some programs access thousands of objects, so running
+          such programs in "learning mode" dulls the system response
+          and consumes much memory.
+          This is the safeguard for such programs.
+
+config SECURITY_TOMOYO_MAX_AUDIT_LOG
+        int "Default maximal count for audit log"
+        default 1024
+        range 0 2147483647
+        depends on SECURITY_TOMOYO
+        help
+          This is the default value for maximal entries for
+          audit logs that the kernel can hold on memory.
+          You can read the log via /sys/kernel/security/tomoyo/audit.
+          If you don't need audit logs, you may set this value to 0.
+
+config SECURITY_TOMOYO_OMIT_USERSPACE_LOADER
+        bool "Activate without calling userspace policy loader."
+        default n
+        depends on SECURITY_TOMOYO
+        ---help---
+          Say Y here if you want to activate access control as soon as built-in
+          policy was loaded. This option will be useful for systems where
+          operations which can lead to the hijacking of the boot sequence are
+          needed before loading the policy. For example, you can activate
+          immediately after loading the fixed part of policy which will allow
+          only operations needed for mounting a partition which contains the
+          variant part of policy and verifying (e.g. running GPG check) and
+          loading the variant part of policy. Since you can start using
+          enforcing mode from the beginning, you can reduce the possibility of
+          hijacking the boot sequence.
+
+config SECURITY_TOMOYO_POLICY_LOADER
+        string "Location of userspace policy loader"
+        default "/sbin/tomoyo-init"
+        depends on SECURITY_TOMOYO
+        depends on !SECURITY_TOMOYO_OMIT_USERSPACE_LOADER
+        ---help---
+          This is the default pathname of policy loader which is called before
+          activation. You can override this setting via TOMOYO_loader= kernel
+          command line option.
+
+config SECURITY_TOMOYO_ACTIVATION_TRIGGER
+        string "Trigger for calling userspace policy loader"
+        default "/sbin/init"
+        depends on SECURITY_TOMOYO
+        depends on !SECURITY_TOMOYO_OMIT_USERSPACE_LOADER
+        ---help---
+          This is the default pathname of activation trigger.
+          You can override this setting via TOMOYO_trigger= kernel command line
+          option. For example, if you pass init=/bin/systemd option, you may
+          want to also pass TOMOYO_trigger=/bin/systemd option.
diff --git a/security/tomoyo/Makefile b/security/tomoyo/Makefile
index 91640e96bd0..95278b71fc2 100644
--- a/security/tomoyo/Makefile
+++ b/security/tomoyo/Makefile
@@ -1 +1,48 @@
-obj-y = common.o domain.o file.o gc.o group.o load_policy.o memory.o mount.o realpath.o securityfs_if.o tomoyo.o util.o
+obj-y = audit.o common.o condition.o domain.o file.o gc.o group.o load_policy.o memory.o mount.o realpath.o securityfs_if.o tomoyo.o util.o
+
+$(obj)/policy/profile.conf:
+        @mkdir -p $(obj)/policy/
+        @echo Creating an empty policy/profile.conf
+        @touch $@
+
+$(obj)/policy/exception_policy.conf:
+        @mkdir -p $(obj)/policy/
+        @echo Creating a default policy/exception_policy.conf
+        @echo initialize_domain /sbin/modprobe from any >> $@
+        @echo initialize_domain /sbin/hotplug from any >> $@
+
+$(obj)/policy/domain_policy.conf:
+        @mkdir -p $(obj)/policy/
+        @echo Creating an empty policy/domain_policy.conf
+        @touch $@
+
+$(obj)/policy/manager.conf:
+        @mkdir -p $(obj)/policy/
+        @echo Creating an empty policy/manager.conf
+        @touch $@
+
+$(obj)/policy/stat.conf:
+        @mkdir -p $(obj)/policy/
+        @echo Creating an empty policy/stat.conf
+        @touch $@
+
+$(obj)/builtin-policy.h: $(obj)/policy/profile.conf $(obj)/policy/exception_policy.conf $(obj)/policy/domain_policy.conf $(obj)/policy/manager.conf $(obj)/policy/stat.conf
+        @echo Generating built-in policy for TOMOYO 2.4.x.
+        @echo "static char tomoyo_builtin_profile[] __initdata =" > $@.tmp
+        @sed -e 's/\\/\\\\/g' -e 's/\"/\\"/g' -e 's/\(.*\)/"\1\\n"/' < $(obj)/policy/profile.conf >> $@.tmp
+        @echo "\"\";" >> $@.tmp
+        @echo "static char tomoyo_builtin_exception_policy[] __initdata =" >> $@.tmp
+        @sed -e 's/\\/\\\\/g' -e 's/\"/\\"/g' -e 's/\(.*\)/"\1\\n"/' < $(obj)/policy/exception_policy.conf >> $@.tmp
+        @echo "\"\";" >> $@.tmp
+        @echo "static char tomoyo_builtin_domain_policy[] __initdata =" >> $@.tmp
+        @sed -e 's/\\/\\\\/g' -e 's/\"/\\"/g' -e 's/\(.*\)/"\1\\n"/' < $(obj)/policy/domain_policy.conf >> $@.tmp
+        @echo "\"\";" >> $@.tmp
+        @echo "static char tomoyo_builtin_manager[] __initdata =" >> $@.tmp
+        @sed -e 's/\\/\\\\/g' -e 's/\"/\\"/g' -e 's/\(.*\)/"\1\\n"/' < $(obj)/policy/manager.conf >> $@.tmp
+        @echo "\"\";" >> $@.tmp
+        @echo "static char tomoyo_builtin_stat[] __initdata =" >> $@.tmp
+        @sed -e 's/\\/\\\\/g' -e 's/\"/\\"/g' -e 's/\(.*\)/"\1\\n"/' < $(obj)/policy/stat.conf >> $@.tmp
+        @echo "\"\";" >> $@.tmp
+        @mv $@.tmp $@
+
+$(obj)/common.o: $(obj)/builtin-policy.h
diff --git a/security/tomoyo/audit.c b/security/tomoyo/audit.c
new file mode 100644
index 00000000000..5dbb1f7617c
--- /dev/null
+++ b/security/tomoyo/audit.c
@@ -0,0 +1,456 @@
+/*
+ * security/tomoyo/audit.c
+ *
+ * Copyright (C) 2005-2011  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;
+}
diff --git a/security/tomoyo/common.c b/security/tomoyo/common.c
index a0d09e56874..2e43aec1c36 100644
--- a/security/tomoyo/common.c
+++ b/security/tomoyo/common.c
@@ -1,9 +1,7 @@
 /*
  * security/tomoyo/common.c
  *
- * Common functions for TOMOYO.
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
  */
 
 #include <linux/uaccess.h>
@@ -11,54 +9,131 @@
 #include <linux/security.h>
 #include "common.h"
 
-static struct tomoyo_profile tomoyo_default_profile = {
-        .learning = &tomoyo_default_profile.preference,
-        .permissive = &tomoyo_default_profile.preference,
-        .enforcing = &tomoyo_default_profile.preference,
-        .preference.enforcing_verbose = true,
-        .preference.learning_max_entry = 2048,
-        .preference.learning_verbose = false,
-        .preference.permissive_verbose = true
+/* 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"
 };
 
-/* Profile version. Currently only 20090903 is defined. */
-static unsigned int tomoyo_profile_version;
+/* 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",
+};
 
-/* Profile table. Memory is allocated as needed. */
-static struct tomoyo_profile *tomoyo_profile_ptr[TOMOYO_MAX_PROFILES];
+/* 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 functionality that takes 4 modes. */
-static const char *tomoyo_mode[4] = {
-        "disabled", "learning", "permissive", "enforcing"
+/* 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 /sys/kernel/security/tomoyo/profile */
-static const char *tomoyo_mac_keywords[TOMOYO_MAX_MAC_INDEX
-                                       + TOMOYO_MAX_MAC_CATEGORY_INDEX] = {
-        [TOMOYO_MAC_FILE_EXECUTE]    = "file::execute",
-        [TOMOYO_MAC_FILE_OPEN]       = "file::open",
-        [TOMOYO_MAC_FILE_CREATE]     = "file::create",
-        [TOMOYO_MAC_FILE_UNLINK]     = "file::unlink",
-        [TOMOYO_MAC_FILE_MKDIR]      = "file::mkdir",
-        [TOMOYO_MAC_FILE_RMDIR]      = "file::rmdir",
-        [TOMOYO_MAC_FILE_MKFIFO]     = "file::mkfifo",
-        [TOMOYO_MAC_FILE_MKSOCK]     = "file::mksock",
-        [TOMOYO_MAC_FILE_TRUNCATE]   = "file::truncate",
-        [TOMOYO_MAC_FILE_SYMLINK]    = "file::symlink",
-        [TOMOYO_MAC_FILE_REWRITE]    = "file::rewrite",
-        [TOMOYO_MAC_FILE_MKBLOCK]    = "file::mkblock",
-        [TOMOYO_MAC_FILE_MKCHAR]     = "file::mkchar",
-        [TOMOYO_MAC_FILE_LINK]       = "file::link",
-        [TOMOYO_MAC_FILE_RENAME]     = "file::rename",
-        [TOMOYO_MAC_FILE_CHMOD]      = "file::chmod",
-        [TOMOYO_MAC_FILE_CHOWN]      = "file::chown",
-        [TOMOYO_MAC_FILE_CHGRP]      = "file::chgrp",
-        [TOMOYO_MAC_FILE_IOCTL]      = "file::ioctl",
-        [TOMOYO_MAC_FILE_CHROOT]     = "file::chroot",
-        [TOMOYO_MAC_FILE_MOUNT]      = "file::mount",
-        [TOMOYO_MAC_FILE_UMOUNT]     = "file::umount",
-        [TOMOYO_MAC_FILE_PIVOT_ROOT] = "file::pivot_root",
-        [TOMOYO_MAX_MAC_INDEX + TOMOYO_MAC_CATEGORY_FILE] = "file",
+/* 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? */
@@ -71,11 +146,20 @@ static bool tomoyo_manage_by_non_root;
  *
  * @value: Bool value.
  */
-static const char *tomoyo_yesno(const unsigned int 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;
@@ -96,7 +180,7 @@ static bool tomoyo_flush(struct tomoyo_io_buffer *head)
 {
         while (head->r.w_pos) {
                 const char *w = head->r.w[0];
-                int len = strlen(w);
+                size_t len = strlen(w);
                 if (len) {
                         if (len > head->read_user_buf_avail)
                                 len = head->read_user_buf_avail;
@@ -111,7 +195,7 @@ static bool tomoyo_flush(struct tomoyo_io_buffer *head)
                 head->r.w[0] = w;
                 if (*w)
                         return false;
-                /* Add '\0' for query. */
+                /* Add '\0' for audit logs and query. */
                 if (head->poll) {
                         if (!head->read_user_buf_avail ||
                             copy_to_user(head->read_user_buf, "", 1))
@@ -155,8 +239,8 @@ static void tomoyo_set_string(struct tomoyo_io_buffer *head, const char *string)
 void tomoyo_io_printf(struct tomoyo_io_buffer *head, const char *fmt, ...)
 {
         va_list args;
-        int len;
-        int pos = head->r.avail;
+        size_t len;
+        size_t pos = head->r.avail;
         int size = head->readbuf_size - pos;
         if (size <= 0)
                 return;
@@ -171,11 +255,25 @@ void tomoyo_io_printf(struct tomoyo_io_buffer *head, const char *fmt, ...)
         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");
@@ -183,6 +281,62 @@ static bool tomoyo_set_lf(struct tomoyo_io_buffer *head)
 }
 
 /**
+ * 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".
@@ -192,7 +346,7 @@ static void tomoyo_print_name_union(struct tomoyo_io_buffer *head,
                                     const struct tomoyo_name_union *ptr)
 {
         tomoyo_set_space(head);
-        if (ptr->is_group) {
+        if (ptr->group) {
                 tomoyo_set_string(head, "@");
                 tomoyo_set_string(head, ptr->group->group_name->name);
         } else {
@@ -201,24 +355,46 @@ static void tomoyo_print_name_union(struct tomoyo_io_buffer *head,
 }
 
 /**
- * tomoyo_print_number_union - Print a tomoyo_number_union.
+ * 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_number_union".
+ * @head: Pointer to "struct tomoyo_io_buffer".
+ * @ptr:  Pointer to "struct tomoyo_name_union".
+ *
+ * Returns nothing.
  */
-static void tomoyo_print_number_union(struct tomoyo_io_buffer *head,
-                                      const struct tomoyo_number_union *ptr)
+static void tomoyo_print_name_union_quoted(struct tomoyo_io_buffer *head,
+                                           const struct tomoyo_name_union *ptr)
 {
-        tomoyo_set_space(head);
-        if (ptr->is_group) {
+        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->min_type;
-                const u8 max_type = ptr->max_type;
+                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++) {
@@ -232,8 +408,8 @@ static void tomoyo_print_number_union(struct tomoyo_io_buffer *head,
                                                  "0%lo", min);
                                 break;
                         default:
-                                tomoyo_addprintf(buffer, sizeof(buffer),
-                                                 "%lu", min);
+                                tomoyo_addprintf(buffer, sizeof(buffer), "%lu",
+                                                 min);
                                 break;
                         }
                         if (min == max && min_type == max_type)
@@ -247,35 +423,53 @@ static void tomoyo_print_number_union(struct tomoyo_io_buffer *head,
 }
 
 /**
+ * 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(const unsigned int profile)
+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 = tomoyo_profile_ptr[profile];
+        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 = tomoyo_profile_ptr[profile];
+        ptr = ns->profile_ptr[profile];
         if (!ptr && tomoyo_memory_ok(entry)) {
                 ptr = entry;
-                ptr->learning = &tomoyo_default_profile.preference;
-                ptr->permissive = &tomoyo_default_profile.preference;
-                ptr->enforcing = &tomoyo_default_profile.preference;
-                ptr->default_config = TOMOYO_CONFIG_DISABLED;
+                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. */
-                tomoyo_profile_ptr[profile] = ptr;
+                ns->profile_ptr[profile] = ptr;
                 entry = NULL;
         }
         mutex_unlock(&tomoyo_policy_lock);
@@ -287,19 +481,29 @@ static struct tomoyo_profile *tomoyo_assign_profile(const unsigned int profile)
 /**
  * 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 u8 profile)
+struct tomoyo_profile *tomoyo_profile(const struct tomoyo_policy_namespace *ns,
+                                      const u8 profile)
 {
-        struct tomoyo_profile *ptr = tomoyo_profile_ptr[profile];
-        if (!tomoyo_policy_loaded)
-                return &tomoyo_default_profile;
-        BUG_ON(!ptr);
+        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);
@@ -313,18 +517,15 @@ static s8 tomoyo_find_yesno(const char *string, const char *find)
         return -1;
 }
 
-static void tomoyo_set_bool(bool *b, const char *string, const char *find)
-{
-        switch (tomoyo_find_yesno(string, find)) {
-        case 1:
-                *b = true;
-                break;
-        case 0:
-                *b = false;
-                break;
-        }
-}
-
+/**
+ * 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)
 {
@@ -333,51 +534,16 @@ static void tomoyo_set_uint(unsigned int *i, const char *string,
                 sscanf(cp + strlen(find), "=%u", i);
 }
 
-static void tomoyo_set_pref(const char *name, const char *value,
-                            const bool use_default,
-                            struct tomoyo_profile *profile)
-{
-        struct tomoyo_preference **pref;
-        bool *verbose;
-        if (!strcmp(name, "enforcing")) {
-                if (use_default) {
-                        pref = &profile->enforcing;
-                        goto set_default;
-                }
-                profile->enforcing = &profile->preference;
-                verbose = &profile->preference.enforcing_verbose;
-                goto set_verbose;
-        }
-        if (!strcmp(name, "permissive")) {
-                if (use_default) {
-                        pref = &profile->permissive;
-                        goto set_default;
-                }
-                profile->permissive = &profile->preference;
-                verbose = &profile->preference.permissive_verbose;
-                goto set_verbose;
-        }
-        if (!strcmp(name, "learning")) {
-                if (use_default) {
-                        pref = &profile->learning;
-                        goto set_default;
-                }
-                profile->learning = &profile->preference;
-                tomoyo_set_uint(&profile->preference.learning_max_entry, value,
-                             "max_entry");
-                verbose = &profile->preference.learning_verbose;
-                goto set_verbose;
-        }
-        return;
- set_default:
-        *pref = &tomoyo_default_profile.preference;
-        return;
- set_verbose:
-        tomoyo_set_bool(verbose, value, "verbose");
-}
-
+/**
+ * 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,
-                           const bool use_default,
                            struct tomoyo_profile *profile)
 {
         u8 i;
@@ -389,7 +555,17 @@ static int tomoyo_set_mode(char *name, const char *value,
                 config = 0;
                 for (i = 0; i < TOMOYO_MAX_MAC_INDEX
                              + TOMOYO_MAX_MAC_CATEGORY_INDEX; i++) {
-                        if (strcmp(name, tomoyo_mac_keywords[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;
@@ -399,7 +575,7 @@ static int tomoyo_set_mode(char *name, const char *value,
         } else {
                 return -EINVAL;
         }
-        if (use_default) {
+        if (strstr(value, "use_default")) {
                 config = TOMOYO_CONFIG_USE_DEFAULT;
         } else {
                 u8 mode;
@@ -410,6 +586,24 @@ static int tomoyo_set_mode(char *name, const char *value,
                                  * '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;
@@ -429,34 +623,22 @@ static int tomoyo_write_profile(struct tomoyo_io_buffer *head)
 {
         char *data = head->write_buf;
         unsigned int i;
-        bool use_default = false;
         char *cp;
         struct tomoyo_profile *profile;
-        if (sscanf(data, "PROFILE_VERSION=%u", &tomoyo_profile_version) == 1)
+        if (sscanf(data, "PROFILE_VERSION=%u", &head->w.ns->profile_version)
+            == 1)
                 return 0;
         i = simple_strtoul(data, &cp, 10);
-        if (data == cp) {
-                profile = &tomoyo_default_profile;
-        } else {
-                if (*cp != '-')
-                        return -EINVAL;
-                data = cp + 1;
-                profile = tomoyo_assign_profile(i);
-                if (!profile)
-                        return -EINVAL;
-        }
+        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 (profile != &tomoyo_default_profile)
-                use_default = strstr(cp, "use_default") != NULL;
-        if (tomoyo_str_starts(&data, "PREFERENCE::")) {
-                tomoyo_set_pref(data, cp, use_default, profile);
-                return 0;
-        }
-        if (profile == &tomoyo_default_profile)
-                return -EINVAL;
         if (!strcmp(data, "COMMENT")) {
                 static DEFINE_SPINLOCK(lock);
                 const struct tomoyo_path_info *new_comment
@@ -471,94 +653,91 @@ static int tomoyo_write_profile(struct tomoyo_io_buffer *head)
                 tomoyo_put_name(old_comment);
                 return 0;
         }
-        return tomoyo_set_mode(data, cp, use_default, profile);
-}
-
-static void tomoyo_print_preference(struct tomoyo_io_buffer *head,
-                                    const int idx)
-{
-        struct tomoyo_preference *pref = &tomoyo_default_profile.preference;
-        const struct tomoyo_profile *profile = idx >= 0 ?
-                tomoyo_profile_ptr[idx] : NULL;
-        char buffer[16] = "";
-        if (profile) {
-                buffer[sizeof(buffer) - 1] = '\0';
-                snprintf(buffer, sizeof(buffer) - 1, "%u-", idx);
-        }
-        if (profile) {
-                pref = profile->learning;
-                if (pref == &tomoyo_default_profile.preference)
-                        goto skip1;
-        }
-        tomoyo_io_printf(head, "%sPREFERENCE::%s={ "
-                         "verbose=%s max_entry=%u }\n",
-                         buffer, "learning",
-                         tomoyo_yesno(pref->learning_verbose),
-                         pref->learning_max_entry);
- skip1:
-        if (profile) {
-                pref = profile->permissive;
-                if (pref == &tomoyo_default_profile.preference)
-                        goto skip2;
-        }
-        tomoyo_io_printf(head, "%sPREFERENCE::%s={ verbose=%s }\n",
-                         buffer, "permissive",
-                         tomoyo_yesno(pref->permissive_verbose));
- skip2:
-        if (profile) {
-                pref = profile->enforcing;
-                if (pref == &tomoyo_default_profile.preference)
-                        return;
+        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;
         }
-        tomoyo_io_printf(head, "%sPREFERENCE::%s={ verbose=%s }\n",
-                         buffer, "enforcing",
-                         tomoyo_yesno(pref->enforcing_verbose));
+        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 }\n", tomoyo_mode[config & 3]);
+        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 = tomoyo_profile_ptr[index];
+        profile = ns->profile_ptr[index];
         switch (head->r.step) {
         case 0:
-                tomoyo_io_printf(head, "PROFILE_VERSION=%s\n", "20090903");
-                tomoyo_print_preference(head, -1);
+                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 (tomoyo_profile_ptr[head->r.index])
+                        if (ns->profile_ptr[head->r.index])
                                 break;
-                if (head->r.index == TOMOYO_MAX_PROFILES)
+                if (head->r.index == TOMOYO_MAX_PROFILES) {
+                        head->r.eof = true;
                         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_print_namespace(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;
@@ -572,15 +751,22 @@ static void tomoyo_read_profile(struct tomoyo_io_buffer *head)
                         const u8 config = profile->config[i];
                         if (config == TOMOYO_CONFIG_USE_DEFAULT)
                                 continue;
-                        tomoyo_io_printf(head, "%u-%s%s", index, "CONFIG::",
-                                         tomoyo_mac_keywords[i]);
+                        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) {
-                        tomoyo_print_preference(head, index);
                         head->r.index++;
                         head->r.step = 1;
                 }
@@ -590,6 +776,14 @@ static void tomoyo_read_profile(struct tomoyo_io_buffer *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)
 {
@@ -611,8 +805,13 @@ static int tomoyo_update_manager_entry(const char *manager,
                                        const bool is_delete)
 {
         struct tomoyo_manager e = { };
-        int error;
-
+        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;
@@ -622,12 +821,11 @@ static int tomoyo_update_manager_entry(const char *manager,
                         return -EINVAL;
         }
         e.manager = tomoyo_get_name(manager);
-        if (!e.manager)
-                return -ENOMEM;
-        error = tomoyo_update_policy(&e.head, sizeof(e), is_delete,
-                                     &tomoyo_policy_list[TOMOYO_ID_MANAGER],
-                                     tomoyo_same_manager);
-        tomoyo_put_name(e.manager);
+        if (e.manager) {
+                error = tomoyo_update_policy(&e.head, sizeof(e), &param,
+                                             tomoyo_same_manager);
+                tomoyo_put_name(e.manager);
+        }
         return error;
 }
 
@@ -643,13 +841,12 @@ static int tomoyo_update_manager_entry(const char *manager,
 static int tomoyo_write_manager(struct tomoyo_io_buffer *head)
 {
         char *data = head->write_buf;
-        bool is_delete = tomoyo_str_starts(&data, TOMOYO_KEYWORD_DELETE);
 
         if (!strcmp(data, "manage_by_non_root")) {
-                tomoyo_manage_by_non_root = !is_delete;
+                tomoyo_manage_by_non_root = !head->w.is_delete;
                 return 0;
         }
-        return tomoyo_update_manager_entry(data, is_delete);
+        return tomoyo_update_manager_entry(data, head->w.is_delete);
 }
 
 /**
@@ -663,8 +860,8 @@ static void tomoyo_read_manager(struct tomoyo_io_buffer *head)
 {
         if (head->r.eof)
                 return;
-        list_for_each_cookie(head->r.acl,
-                             &tomoyo_policy_list[TOMOYO_ID_MANAGER]) {
+        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)
@@ -697,8 +894,8 @@ static bool tomoyo_manager(void)
                 return true;
         if (!tomoyo_manage_by_non_root && (task->cred->uid || task->cred->euid))
                 return false;
-        list_for_each_entry_rcu(ptr, &tomoyo_policy_list[TOMOYO_ID_MANAGER],
-                                head.list) {
+        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;
@@ -710,8 +907,8 @@ static bool tomoyo_manager(void)
         exe = tomoyo_get_exe();
         if (!exe)
                 return false;
-        list_for_each_entry_rcu(ptr, &tomoyo_policy_list[TOMOYO_ID_MANAGER],
-                                head.list) {
+        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;
@@ -732,7 +929,7 @@ static bool tomoyo_manager(void)
 }
 
 /**
- * tomoyo_select_one - Parse select command.
+ * tomoyo_select_domain - Parse select command.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
  * @data: String to parse.
@@ -741,16 +938,15 @@ static bool tomoyo_manager(void)
  *
  * Caller holds tomoyo_read_lock().
  */
-static bool tomoyo_select_one(struct tomoyo_io_buffer *head, const char *data)
+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 (!strcmp(data, "allow_execute")) {
-                head->r.print_execute_only = true;
-                return true;
-        }
+        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;
@@ -769,7 +965,7 @@ static bool tomoyo_select_one(struct tomoyo_io_buffer *head, const char *data)
                         domain = tomoyo_find_domain(data + 7);
         } else
                 return false;
-        head->write_var1 = domain;
+        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). */
@@ -821,20 +1017,47 @@ static int tomoyo_delete_domain(char *domainname)
 /**
  * tomoyo_write_domain2 - Write domain policy.
  *
- * @head: Pointer to "struct tomoyo_io_buffer".
+ * @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(char *data, struct tomoyo_domain_info *domain,
+static int tomoyo_write_domain2(struct tomoyo_policy_namespace *ns,
+                                struct list_head *list, char *data,
                                 const bool is_delete)
 {
-        if (tomoyo_str_starts(&data, TOMOYO_KEYWORD_ALLOW_MOUNT))
-                return tomoyo_write_mount(data, domain, is_delete);
-        return tomoyo_write_file(data, domain, 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.
  *
@@ -847,69 +1070,198 @@ static int tomoyo_write_domain2(char *data, struct tomoyo_domain_info *domain,
 static int tomoyo_write_domain(struct tomoyo_io_buffer *head)
 {
         char *data = head->write_buf;
-        struct tomoyo_domain_info *domain = head->write_var1;
-        bool is_delete = false;
-        bool is_select = false;
+        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 (tomoyo_str_starts(&data, TOMOYO_KEYWORD_DELETE))
-                is_delete = true;
-        else if (tomoyo_str_starts(&data, TOMOYO_KEYWORD_SELECT))
-                is_select = true;
-        if (is_select && tomoyo_select_one(head, data))
-                return 0;
-        /* Don't allow updating policies by non manager programs. */
-        if (!tomoyo_manager())
-                return -EPERM;
-        if (tomoyo_domain_def(data)) {
+        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, 0);
-                head->write_var1 = domain;
+                        domain = tomoyo_assign_domain(data, false);
+                head->w.domain = domain;
                 return 0;
         }
         if (!domain)
                 return -EINVAL;
-
-        if (sscanf(data, TOMOYO_KEYWORD_USE_PROFILE "%u", &profile) == 1
+        ns = domain->ns;
+        if (sscanf(data, "use_profile %u", &profile) == 1
             && profile < TOMOYO_MAX_PROFILES) {
-                if (tomoyo_profile_ptr[profile] || !tomoyo_policy_loaded)
+                if (!tomoyo_policy_loaded || ns->profile_ptr[profile])
                         domain->profile = (u8) profile;
                 return 0;
         }
-        if (!strcmp(data, TOMOYO_KEYWORD_IGNORE_GLOBAL_ALLOW_READ)) {
-                domain->ignore_global_allow_read = !is_delete;
+        if (sscanf(data, "use_group %u\n", &profile) == 1
+            && profile < TOMOYO_MAX_ACL_GROUPS) {
+                if (!is_delete)
+                        domain->group = (u8) profile;
                 return 0;
         }
-        if (!strcmp(data, TOMOYO_KEYWORD_QUOTA_EXCEEDED)) {
-                domain->quota_warned = !is_delete;
-                return 0;
-        }
-        if (!strcmp(data, TOMOYO_KEYWORD_TRANSITION_FAILED)) {
-                domain->transition_failed = !is_delete;
+        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(data, domain, is_delete);
+        return tomoyo_write_domain2(ns, &domain->acl_info_list, data,
+                                    is_delete);
 }
 
 /**
- * tomoyo_fns - Find next set bit.
+ * tomoyo_print_condition - Print condition part.
  *
- * @perm: 8 bits value.
- * @bit:  First bit to find.
+ * @head: Pointer to "struct tomoyo_io_buffer".
+ * @cond: Pointer to "struct tomoyo_condition".
  *
- * Returns next on-bit on success, 8 otherwise.
+ * Returns true on success, false otherwise.
  */
-static u8 tomoyo_fns(const u8 perm, u8 bit)
+static bool tomoyo_print_condition(struct tomoyo_io_buffer *head,
+                                   const struct tomoyo_condition *cond)
 {
-        for ( ; bit < 8; bit++)
-                if (perm & (1 << bit))
+        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;
-        return bit;
+                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);
 }
 
 /**
@@ -924,63 +1276,96 @@ 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;
- next:
-        bit = head->r.bit;
         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 < TOMOYO_MAX_PATH_OPERATION; bit++) {
+                for (bit = 0; bit < TOMOYO_MAX_PATH_OPERATION; bit++) {
                         if (!(perm & (1 << bit)))
                                 continue;
-                        if (head->r.print_execute_only &&
+                        if (head->r.print_transition_related_only &&
                             bit != TOMOYO_TYPE_EXECUTE)
                                 continue;
-                        /* Print "read/write" instead of "read" and "write". */
-                        if ((bit == TOMOYO_TYPE_READ ||
-                             bit == TOMOYO_TYPE_WRITE)
-                            && (perm & (1 << TOMOYO_TYPE_READ_WRITE)))
-                                continue;
-                        break;
+                        if (first) {
+                                tomoyo_set_group(head, "file ");
+                                first = false;
+                        } else {
+                                tomoyo_set_slash(head);
+                        }
+                        tomoyo_set_string(head, tomoyo_path_keyword[bit]);
                 }
-                if (bit >= TOMOYO_MAX_PATH_OPERATION)
-                        goto done;
-                tomoyo_io_printf(head, "allow_%s", tomoyo_path_keyword[bit]);
+                if (first)
+                        return true;
                 tomoyo_print_name_union(head, &ptr->name);
-        } else if (head->r.print_execute_only) {
+        } 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);
-                bit = tomoyo_fns(ptr->perm, bit);
-                if (bit >= TOMOYO_MAX_PATH2_OPERATION)
-                        goto done;
-                tomoyo_io_printf(head, "allow_%s", tomoyo_path2_keyword[bit]);
+                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);
-                bit = tomoyo_fns(ptr->perm, bit);
-                if (bit >= TOMOYO_MAX_PATH_NUMBER_OPERATION)
-                        goto done;
-                tomoyo_io_printf(head, "allow_%s",
-                                 tomoyo_path_number_keyword[bit]);
+                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);
-                bit = tomoyo_fns(ptr->perm, bit);
-                if (bit >= TOMOYO_MAX_MKDEV_OPERATION)
-                        goto done;
-                tomoyo_io_printf(head, "allow_%s", tomoyo_mkdev_keyword[bit]);
+                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);
@@ -988,35 +1373,41 @@ static bool tomoyo_print_entry(struct tomoyo_io_buffer *head,
         } else if (acl_type == TOMOYO_TYPE_MOUNT_ACL) {
                 struct tomoyo_mount_acl *ptr =
                         container_of(acl, typeof(*ptr), head);
-                tomoyo_io_printf(head, "allow_mount");
+                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);
         }
-        head->r.bit = bit + 1;
-        tomoyo_io_printf(head, "\n");
-        if (acl_type != TOMOYO_TYPE_MOUNT_ACL)
-                goto next;
- done:
-        head->r.bit = 0;
+        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".
- * @domain: Pointer to "struct tomoyo_domain_info".
+ * @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 tomoyo_domain_info *domain)
+                                struct list_head *list)
 {
-        list_for_each_cookie(head->r.acl, &domain->acl_info_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))
@@ -1041,6 +1432,7 @@ static void tomoyo_read_domain(struct tomoyo_io_buffer *head)
                 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)
@@ -1048,22 +1440,18 @@ static void tomoyo_read_domain(struct tomoyo_io_buffer *head)
                         /* Print domainname and flags. */
                         tomoyo_set_string(head, domain->domainname->name);
                         tomoyo_set_lf(head);
-                        tomoyo_io_printf(head,
-                                         TOMOYO_KEYWORD_USE_PROFILE "%u\n",
+                        tomoyo_io_printf(head, "use_profile %u\n",
                                          domain->profile);
-                        if (domain->quota_warned)
-                                tomoyo_set_string(head, "quota_exceeded\n");
-                        if (domain->transition_failed)
-                                tomoyo_set_string(head, "transition_failed\n");
-                        if (domain->ignore_global_allow_read)
-                                tomoyo_set_string(head,
-                                       TOMOYO_KEYWORD_IGNORE_GLOBAL_ALLOW_READ
-                                                  "\n");
+                        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))
+                        if (!tomoyo_read_domain2(head, &domain->acl_info_list))
                                 return;
                         head->r.step++;
                         if (!tomoyo_set_lf(head))
@@ -1080,73 +1468,6 @@ static void tomoyo_read_domain(struct tomoyo_io_buffer *head)
 }
 
 /**
- * tomoyo_write_domain_profile - Assign profile for specified domain.
- *
- * @head: Pointer to "struct tomoyo_io_buffer".
- *
- * Returns 0 on success, -EINVAL otherwise.
- *
- * This is equivalent to doing
- *
- *     ( echo "select " $domainname; echo "use_profile " $profile ) |
- *     /usr/sbin/tomoyo-loadpolicy -d
- *
- * Caller holds tomoyo_read_lock().
- */
-static int tomoyo_write_domain_profile(struct tomoyo_io_buffer *head)
-{
-        char *data = head->write_buf;
-        char *cp = strchr(data, ' ');
-        struct tomoyo_domain_info *domain;
-        unsigned long profile;
-
-        if (!cp)
-                return -EINVAL;
-        *cp = '\0';
-        domain = tomoyo_find_domain(cp + 1);
-        if (strict_strtoul(data, 10, &profile))
-                return -EINVAL;
-        if (domain && profile < TOMOYO_MAX_PROFILES
-            && (tomoyo_profile_ptr[profile] || !tomoyo_policy_loaded))
-                domain->profile = (u8) profile;
-        return 0;
-}
-
-/**
- * tomoyo_read_domain_profile - Read only domainname and profile.
- *
- * @head: Pointer to "struct tomoyo_io_buffer".
- *
- * Returns list of profile number and domainname pairs.
- *
- * This is equivalent to doing
- *
- *     grep -A 1 '^<kernel>' /sys/kernel/security/tomoyo/domain_policy |
- *     awk ' { if ( domainname == "" ) { if ( $1 == "<kernel>" )
- *     domainname = $0; } else if ( $1 == "use_profile" ) {
- *     print $2 " " domainname; domainname = ""; } } ; '
- *
- * Caller holds tomoyo_read_lock().
- */
-static void tomoyo_read_domain_profile(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);
-                if (domain->is_deleted)
-                        continue;
-                if (!tomoyo_flush(head))
-                        return;
-                tomoyo_io_printf(head, "%u ", domain->profile);
-                tomoyo_set_string(head, domain->domainname->name);
-                tomoyo_set_lf(head);
-        }
-        head->r.eof = true;
-}
-
-/**
  * tomoyo_write_pid: Specify PID to obtain domainname.
  *
  * @head: Pointer to "struct tomoyo_io_buffer".
@@ -1204,18 +1525,20 @@ static void tomoyo_read_pid(struct tomoyo_io_buffer *head)
         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_INITIALIZE]
-        = TOMOYO_KEYWORD_NO_INITIALIZE_DOMAIN,
-        [TOMOYO_TRANSITION_CONTROL_INITIALIZE]
-        = TOMOYO_KEYWORD_INITIALIZE_DOMAIN,
-        [TOMOYO_TRANSITION_CONTROL_NO_KEEP] = TOMOYO_KEYWORD_NO_KEEP_DOMAIN,
-        [TOMOYO_TRANSITION_CONTROL_KEEP] = TOMOYO_KEYWORD_KEEP_DOMAIN
+        [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] = TOMOYO_KEYWORD_PATH_GROUP,
-        [TOMOYO_NUMBER_GROUP] = TOMOYO_KEYWORD_NUMBER_GROUP
+        [TOMOYO_PATH_GROUP]   = "path_group ",
+        [TOMOYO_NUMBER_GROUP] = "number_group ",
 };
 
 /**
@@ -1229,29 +1552,30 @@ static const char *tomoyo_group_name[TOMOYO_MAX_GROUP] = {
  */
 static int tomoyo_write_exception(struct tomoyo_io_buffer *head)
 {
-        char *data = head->write_buf;
-        bool is_delete = tomoyo_str_starts(&data, TOMOYO_KEYWORD_DELETE);
-        u8 i;
-        static const struct {
-                const char *keyword;
-                int (*write) (char *, const bool);
-        } tomoyo_callback[4] = {
-                { TOMOYO_KEYWORD_AGGREGATOR, tomoyo_write_aggregator },
-                { TOMOYO_KEYWORD_FILE_PATTERN, tomoyo_write_pattern },
-                { TOMOYO_KEYWORD_DENY_REWRITE, tomoyo_write_no_rewrite },
-                { TOMOYO_KEYWORD_ALLOW_READ, tomoyo_write_globally_readable },
+        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(&data, tomoyo_transition_type[i]))
-                        return tomoyo_write_transition_control(data, is_delete,
-                                                               i);
-        for (i = 0; i < 4; i++)
-                if (tomoyo_str_starts(&data, tomoyo_callback[i].keyword))
-                        return tomoyo_callback[i].write(data, is_delete);
+                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(&data, tomoyo_group_name[i]))
-                        return tomoyo_write_group(data, is_delete, 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;
 }
 
@@ -1267,9 +1591,12 @@ static int tomoyo_write_exception(struct tomoyo_io_buffer *head)
  */
 static bool tomoyo_read_group(struct tomoyo_io_buffer *head, const int idx)
 {
-        list_for_each_cookie(head->r.group, &tomoyo_group_list[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), list);
+                        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);
@@ -1277,6 +1604,7 @@ static bool tomoyo_read_group(struct tomoyo_io_buffer *head, const int idx)
                                 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) {
@@ -1310,7 +1638,10 @@ static bool tomoyo_read_group(struct tomoyo_io_buffer *head, const int idx)
  */
 static bool tomoyo_read_policy(struct tomoyo_io_buffer *head, const int idx)
 {
-        list_for_each_cookie(head->r.acl, &tomoyo_policy_list[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)
@@ -1322,35 +1653,23 @@ static bool tomoyo_read_policy(struct tomoyo_io_buffer *head, const int idx)
                         {
                                 struct tomoyo_transition_control *ptr =
                                         container_of(acl, typeof(*ptr), head);
-                                tomoyo_set_string(head,
-                                                  tomoyo_transition_type
+                                tomoyo_print_namespace(head);
+                                tomoyo_set_string(head, tomoyo_transition_type
                                                   [ptr->type]);
-                                if (ptr->program)
-                                        tomoyo_set_string(head,
-                                                          ptr->program->name);
-                                if (ptr->program && ptr->domainname)
-                                        tomoyo_set_string(head, " from ");
-                                if (ptr->domainname)
-                                        tomoyo_set_string(head,
-                                                          ptr->domainname->
-                                                          name);
-                        }
-                        break;
-                case TOMOYO_ID_GLOBALLY_READABLE:
-                        {
-                                struct tomoyo_readable_file *ptr =
-                                        container_of(acl, typeof(*ptr), head);
-                                tomoyo_set_string(head,
-                                                  TOMOYO_KEYWORD_ALLOW_READ);
-                                tomoyo_set_string(head, ptr->filename->name);
+                                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_set_string(head,
-                                                  TOMOYO_KEYWORD_AGGREGATOR);
+                                tomoyo_print_namespace(head);
+                                tomoyo_set_string(head, "aggregator ");
                                 tomoyo_set_string(head,
                                                   ptr->original_name->name);
                                 tomoyo_set_space(head);
@@ -1358,24 +1677,6 @@ static bool tomoyo_read_policy(struct tomoyo_io_buffer *head, const int idx)
                                                ptr->aggregated_name->name);
                         }
                         break;
-                case TOMOYO_ID_PATTERN:
-                        {
-                                struct tomoyo_no_pattern *ptr =
-                                        container_of(acl, typeof(*ptr), head);
-                                tomoyo_set_string(head,
-                                                  TOMOYO_KEYWORD_FILE_PATTERN);
-                                tomoyo_set_string(head, ptr->pattern->name);
-                        }
-                        break;
-                case TOMOYO_ID_NO_REWRITE:
-                        {
-                                struct tomoyo_no_rewrite *ptr =
-                                        container_of(acl, typeof(*ptr), head);
-                                tomoyo_set_string(head,
-                                                  TOMOYO_KEYWORD_DENY_REWRITE);
-                                tomoyo_set_string(head, ptr->pattern->name);
-                        }
-                        break;
                 default:
                         continue;
                 }
@@ -1394,6 +1695,8 @@ static bool tomoyo_read_policy(struct tomoyo_io_buffer *head, const int idx)
  */
 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 &&
@@ -1406,95 +1709,40 @@ static void tomoyo_read_exception(struct tomoyo_io_buffer *head)
                 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;
 }
 
-/**
- * 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 timeval tv;
-        const pid_t gpid = task_pid_nr(current);
-        static const int tomoyo_buffer_len = 4096;
-        char *buffer = kmalloc(tomoyo_buffer_len, GFP_NOFS);
-        pid_t ppid;
-        if (!buffer)
-                return NULL;
-        do_gettimeofday(&tv);
-        rcu_read_lock();
-        ppid = task_tgid_vnr(current->real_parent);
-        rcu_read_unlock();
-        snprintf(buffer, tomoyo_buffer_len - 1,
-                 "#timestamp=%lu profile=%u mode=%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 }",
-                 tv.tv_sec, r->profile, tomoyo_mode[r->mode], gpid,
-                 task_tgid_vnr(current), ppid,
-                 current_uid(), current_gid(), current_euid(),
-                 current_egid(), current_suid(), current_sgid(),
-                 current_fsuid(), current_fsgid());
-        return buffer;
-}
-
-/**
- * tomoyo_init_audit_log - Allocate buffer for audit logs.
- *
- * @len: Required size.
- * @r:   Pointer to "struct tomoyo_request_info".
- *
- * Returns pointer to allocated memory.
- *
- * The @len is updated to add the header lines' size on success.
- *
- * This function uses kzalloc(), so caller must kfree() if this function
- * didn't return NULL.
- */
-static char *tomoyo_init_audit_log(int *len, struct tomoyo_request_info *r)
-{
-        char *buf = NULL;
-        const char *header;
-        const char *domainname;
-        if (!r->domain)
-                r->domain = tomoyo_domain();
-        domainname = r->domain->domainname->name;
-        header = tomoyo_print_header(r);
-        if (!header)
-                return NULL;
-        *len += strlen(domainname) + strlen(header) + 10;
-        buf = kzalloc(*len, GFP_NOFS);
-        if (buf)
-                snprintf(buf, (*len) - 1, "%s\n%s\n", header, domainname);
-        kfree(header);
-        return buf;
-}
-
-/* Wait queue for tomoyo_query_list. */
+/* Wait queue for kernel -> userspace notification. */
 static DECLARE_WAIT_QUEUE_HEAD(tomoyo_query_wait);
-
-/* Lock for manipulating tomoyo_query_list. */
-static DEFINE_SPINLOCK(tomoyo_query_list_lock);
+/* 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;
-        int query_len;
+        size_t query_len;
         unsigned int serial;
-        int timer;
-        int answer;
+        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.
@@ -1502,10 +1750,82 @@ static LIST_HEAD(tomoyo_query_list);
 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.
+ * @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
@@ -1515,88 +1835,79 @@ static atomic_t tomoyo_query_observers = ATOMIC_INIT(0);
 int tomoyo_supervisor(struct tomoyo_request_info *r, const char *fmt, ...)
 {
         va_list args;
-        int error = -EPERM;
-        int pos;
+        int error;
         int len;
         static unsigned int tomoyo_serial;
-        struct tomoyo_query *entry = NULL;
+        struct tomoyo_query entry = { };
         bool quota_exceeded = false;
-        char *header;
+        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) {
-                char *buffer;
+        case TOMOYO_CONFIG_ENFORCING:
+                error = -EPERM;
+                if (atomic_read(&tomoyo_query_observers))
+                        break;
+                goto out;
         case TOMOYO_CONFIG_LEARNING:
-                if (!tomoyo_domain_quota_is_ok(r))
-                        return 0;
-                va_start(args, fmt);
-                len = vsnprintf((char *) &pos, sizeof(pos) - 1, fmt, args) + 4;
-                va_end(args);
-                buffer = kmalloc(len, GFP_NOFS);
-                if (!buffer)
-                        return 0;
-                va_start(args, fmt);
-                vsnprintf(buffer, len - 1, fmt, args);
-                va_end(args);
-                tomoyo_normalize_line(buffer);
-                tomoyo_write_domain2(buffer, r->domain, false);
-                kfree(buffer);
+                error = 0;
+                /* Check max_learning_entry parameter. */
+                if (tomoyo_domain_quota_is_ok(r))
+                        break;
                 /* fall through */
-        case TOMOYO_CONFIG_PERMISSIVE:
+        default:
                 return 0;
         }
-        if (!r->domain)
-                r->domain = tomoyo_domain();
-        if (!atomic_read(&tomoyo_query_observers))
-                return -EPERM;
+        /* Get message. */
         va_start(args, fmt);
-        len = vsnprintf((char *) &pos, sizeof(pos) - 1, fmt, args) + 32;
+        entry.query = tomoyo_init_log(r, len, fmt, args);
         va_end(args);
-        header = tomoyo_init_audit_log(&len, r);
-        if (!header)
+        if (!entry.query)
                 goto out;
-        entry = kzalloc(sizeof(*entry), GFP_NOFS);
-        if (!entry)
+        entry.query_len = strlen(entry.query) + 1;
+        if (!error) {
+                tomoyo_add_entry(r->domain, entry.query);
                 goto out;
-        entry->query = kzalloc(len, GFP_NOFS);
-        if (!entry->query)
-                goto out;
-        len = ksize(entry->query);
+        }
+        len = tomoyo_round2(entry.query_len);
         spin_lock(&tomoyo_query_list_lock);
-        if (tomoyo_quota_for_query && tomoyo_query_memory_size + len +
-            sizeof(*entry) >= tomoyo_quota_for_query) {
+        if (tomoyo_memory_quota[TOMOYO_MEMORY_QUERY] &&
+            tomoyo_memory_used[TOMOYO_MEMORY_QUERY] + len
+            >= tomoyo_memory_quota[TOMOYO_MEMORY_QUERY]) {
                 quota_exceeded = true;
         } else {
-                tomoyo_query_memory_size += len + sizeof(*entry);
-                entry->serial = tomoyo_serial++;
+                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;
-        pos = snprintf(entry->query, len - 1, "Q%u-%hu\n%s",
-                       entry->serial, r->retry, header);
-        kfree(header);
-        header = NULL;
-        va_start(args, fmt);
-        vsnprintf(entry->query + pos, len - 1 - pos, fmt, args);
-        entry->query_len = strlen(entry->query) + 1;
-        va_end(args);
-        spin_lock(&tomoyo_query_list_lock);
-        list_add_tail(&entry->list, &tomoyo_query_list);
-        spin_unlock(&tomoyo_query_list_lock);
         /* Give 10 seconds for supervisor's opinion. */
-        for (entry->timer = 0;
-             atomic_read(&tomoyo_query_observers) && entry->timer < 100;
-             entry->timer++) {
-                wake_up(&tomoyo_query_wait);
-                set_current_state(TASK_INTERRUPTIBLE);
-                schedule_timeout(HZ / 10);
-                if (entry->answer)
+        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_query_memory_size -= len + sizeof(*entry);
+        list_del(&entry.list);
+        tomoyo_memory_used[TOMOYO_MEMORY_QUERY] -= len;
         spin_unlock(&tomoyo_query_list_lock);
-        switch (entry->answer) {
+        switch (entry.answer) {
         case 3: /* Asked to retry by administrator. */
                 error = TOMOYO_RETRY_REQUEST;
                 r->retry++;
@@ -1605,18 +1916,12 @@ int tomoyo_supervisor(struct tomoyo_request_info *r, const char *fmt, ...)
                 /* Granted by administrator. */
                 error = 0;
                 break;
-        case 0:
-                /* Timed out. */
-                break;
         default:
-                /* Rejected by administrator. */
+                /* Timed out or rejected by administrator. */
                 break;
         }
- out:
-        if (entry)
-                kfree(entry->query);
-        kfree(entry);
-        kfree(header);
+out:
+        kfree(entry.query);
         return error;
 }
 
@@ -1663,8 +1968,8 @@ static int tomoyo_poll_query(struct file *file, poll_table *wait)
 static void tomoyo_read_query(struct tomoyo_io_buffer *head)
 {
         struct list_head *tmp;
-        int pos = 0;
-        int len = 0;
+        unsigned int pos = 0;
+        size_t len = 0;
         char *buf;
         if (head->r.w_pos)
                 return;
@@ -1687,7 +1992,7 @@ static void tomoyo_read_query(struct tomoyo_io_buffer *head)
                 head->r.query_index = 0;
                 return;
         }
-        buf = kzalloc(len, GFP_NOFS);
+        buf = kzalloc(len + 32, GFP_NOFS);
         if (!buf)
                 return;
         pos = 0;
@@ -1703,7 +2008,8 @@ static void tomoyo_read_query(struct tomoyo_io_buffer *head)
                  * can change, but I don't care.
                  */
                 if (len == ptr->query_len)
-                        memmove(buf, 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);
@@ -1760,7 +2066,7 @@ static int tomoyo_write_answer(struct tomoyo_io_buffer *head)
 static void tomoyo_read_version(struct tomoyo_io_buffer *head)
 {
         if (!head->r.eof) {
-                tomoyo_io_printf(head, "2.3.0");
+                tomoyo_io_printf(head, "2.4.0");
                 head->r.eof = true;
         }
 }
@@ -1785,15 +2091,111 @@ static void tomoyo_read_self_domain(struct tomoyo_io_buffer *head)
         }
 }
 
+/* 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".
  *
- * Associates policy handler and returns 0 on success, -ENOMEM otherwise.
- *
- * Caller acquires tomoyo_read_lock().
+ * Returns 0 on success, negative value otherwise.
  */
 int tomoyo_open_control(const u8 type, struct file *file)
 {
@@ -1814,15 +2216,15 @@ int tomoyo_open_control(const u8 type, struct file *file)
                 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_DOMAIN_STATUS:
-                /* /sys/kernel/security/tomoyo/.domain_status */
-                head->write = tomoyo_write_domain_profile;
-                head->read = tomoyo_read_domain_profile;
-                break;
         case TOMOYO_PROCESS_STATUS:
                 /* /sys/kernel/security/tomoyo/.process_status */
                 head->write = tomoyo_write_pid;
@@ -1833,11 +2235,11 @@ int tomoyo_open_control(const u8 type, struct file *file)
                 head->read = tomoyo_read_version;
                 head->readbuf_size = 128;
                 break;
-        case TOMOYO_MEMINFO:
-                /* /sys/kernel/security/tomoyo/meminfo */
-                head->write = tomoyo_write_memory_quota;
-                head->read = tomoyo_read_memory_counter;
-                head->readbuf_size = 512;
+        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 */
@@ -1887,26 +2289,16 @@ int tomoyo_open_control(const u8 type, struct file *file)
                         return -ENOMEM;
                 }
         }
-        if (type != TOMOYO_QUERY)
-                head->reader_idx = tomoyo_read_lock();
-        file->private_data = head;
-        /*
-         * Call the handler now if the file is
-         * /sys/kernel/security/tomoyo/self_domain
-         * so that the user can use
-         * cat < /sys/kernel/security/tomoyo/self_domain"
-         * to know the current process's domainname.
-         */
-        if (type == TOMOYO_SELFDOMAIN)
-                tomoyo_read_control(file, NULL, 0);
         /*
          * 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.
          */
-        else if (type == TOMOYO_QUERY)
+        if (type == TOMOYO_QUERY)
                 atomic_inc(&tomoyo_query_observers);
+        file->private_data = head;
+        tomoyo_notify_gc(head, true);
         return 0;
 }
 
@@ -1917,7 +2309,8 @@ int tomoyo_open_control(const u8 type, struct file *file)
  * @wait: Pointer to "poll_table".
  *
  * Waits for read readiness.
- * /sys/kernel/security/tomoyo/query is handled by /usr/sbin/tomoyo-queryd .
+ * /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)
 {
@@ -1928,21 +2321,58 @@ int tomoyo_poll_control(struct file *file, poll_table *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.
  *
- * @file:       Pointer to "struct file".
+ * @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.
- *
- * Caller holds tomoyo_read_lock().
  */
-int tomoyo_read_control(struct file *file, char __user *buffer,
-                        const int buffer_len)
+ssize_t tomoyo_read_control(struct tomoyo_io_buffer *head, char __user *buffer,
+                            const int buffer_len)
 {
         int len;
-        struct tomoyo_io_buffer *head = file->private_data;
+        int idx;
 
         if (!head->read)
                 return -ENOSYS;
@@ -1950,64 +2380,156 @@ int tomoyo_read_control(struct file *file, char __user *buffer,
                 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. */
-                head->read(head);
-        tomoyo_flush(head);
+                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.
  *
- * @file:       Pointer to "struct file".
+ * @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.
- *
- * Caller holds tomoyo_read_lock().
  */
-int tomoyo_write_control(struct file *file, const char __user *buffer,
-                         const int buffer_len)
+ssize_t tomoyo_write_control(struct tomoyo_io_buffer *head,
+                             const char __user *buffer, const int buffer_len)
 {
-        struct tomoyo_io_buffer *head = file->private_data;
         int error = buffer_len;
-        int avail_len = 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;
-        /* Don't allow updating policies by non manager programs. */
-        if (head->write != tomoyo_write_pid &&
-            head->write != tomoyo_write_domain && !tomoyo_manager())
-                return -EPERM;
         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->write_avail >= head->writebuf_size - 1) {
-                        error = -ENOMEM;
-                        break;
-                } else if (get_user(c, buffer)) {
+                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->write_avail++] = c;
+                cp0[head->w.avail++] = c;
                 if (c != '\n')
                         continue;
-                cp0[head->write_avail - 1] = '\0';
-                head->write_avail = 0;
+                cp0[head->w.avail - 1] = '\0';
+                head->w.avail = 0;
                 tomoyo_normalize_line(cp0);
-                head->write(head);
+                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;
 }
@@ -2015,35 +2537,20 @@ int tomoyo_write_control(struct file *file, const char __user *buffer,
 /**
  * tomoyo_close_control - close() for /sys/kernel/security/tomoyo/ interface.
  *
- * @file: Pointer to "struct file".
- *
- * Releases memory and returns 0.
+ * @head: Pointer to "struct tomoyo_io_buffer".
  *
- * Caller looses tomoyo_read_lock().
+ * Returns 0.
  */
-int tomoyo_close_control(struct file *file)
+int tomoyo_close_control(struct tomoyo_io_buffer *head)
 {
-        struct tomoyo_io_buffer *head = file->private_data;
-        const bool is_write = !!head->write_buf;
-
         /*
          * If the file is /sys/kernel/security/tomoyo/query , decrement the
          * observer counter.
          */
-        if (head->type == TOMOYO_QUERY)
-                atomic_dec(&tomoyo_query_observers);
-        else
-                tomoyo_read_unlock(head->reader_idx);
-        /* Release memory used for policy I/O. */
-        kfree(head->read_buf);
-        head->read_buf = NULL;
-        kfree(head->write_buf);
-        head->write_buf = NULL;
-        kfree(head);
-        head = NULL;
-        file->private_data = NULL;
-        if (is_write)
-                tomoyo_run_gc();
+        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;
 }
 
@@ -2055,27 +2562,90 @@ void tomoyo_check_profile(void)
         struct tomoyo_domain_info *domain;
         const int idx = tomoyo_read_lock();
         tomoyo_policy_loaded = true;
-        /* Check all profiles currently assigned to domains are defined. */
+        printk(KERN_INFO "TOMOYO: 2.4.0\n");
         list_for_each_entry_rcu(domain, &tomoyo_domain_list, list) {
                 const u8 profile = domain->profile;
-                if (tomoyo_profile_ptr[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 "You need to define profile %u before using it.\n",
-                       profile);
-                printk(KERN_ERR "Please see http://tomoyo.sourceforge.jp/2.3/ "
+                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("Profile %u (used by '%s') not defined.\n",
-                      profile, domain->domainname->name);
+                panic("STOP!");
         }
         tomoyo_read_unlock(idx);
-        if (tomoyo_profile_version != 20090903) {
-                printk(KERN_ERR "You need to install userland programs for "
-                       "TOMOYO 2.3 and initialize policy configuration.\n");
-                printk(KERN_ERR "Please see http://tomoyo.sourceforge.jp/2.3/ "
-                       "for more information.\n");
-                panic("Profile version %u is not supported.\n",
-                      tomoyo_profile_version);
-        }
-        printk(KERN_INFO "TOMOYO: 2.3.0\n");
         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
+}
diff --git a/security/tomoyo/common.h b/security/tomoyo/common.h
index 7c66bd89878..f7fbaa66e44 100644
--- a/security/tomoyo/common.h
+++ b/security/tomoyo/common.h
@@ -21,7 +21,8 @@
 #include <linux/list.h>
 #include <linux/cred.h>
 #include <linux/poll.h>
-struct linux_binprm;
+#include <linux/binfmts.h>
+#include <linux/highmem.h>
 
 /********** Constants definitions. **********/
 
@@ -38,66 +39,149 @@ struct linux_binprm;
 /* Profile number is an integer between 0 and 255. */
 #define TOMOYO_MAX_PROFILES 256
 
+/* Group number is an integer between 0 and 255. */
+#define TOMOYO_MAX_ACL_GROUPS 256
+
+/* Index numbers for "struct tomoyo_condition". */
+enum tomoyo_conditions_index {
+        TOMOYO_TASK_UID,             /* current_uid()   */
+        TOMOYO_TASK_EUID,            /* current_euid()  */
+        TOMOYO_TASK_SUID,            /* current_suid()  */
+        TOMOYO_TASK_FSUID,           /* current_fsuid() */
+        TOMOYO_TASK_GID,             /* current_gid()   */
+        TOMOYO_TASK_EGID,            /* current_egid()  */
+        TOMOYO_TASK_SGID,            /* current_sgid()  */
+        TOMOYO_TASK_FSGID,           /* current_fsgid() */
+        TOMOYO_TASK_PID,             /* sys_getpid()   */
+        TOMOYO_TASK_PPID,            /* sys_getppid()  */
+        TOMOYO_EXEC_ARGC,            /* "struct linux_binprm *"->argc */
+        TOMOYO_EXEC_ENVC,            /* "struct linux_binprm *"->envc */
+        TOMOYO_TYPE_IS_SOCKET,       /* S_IFSOCK */
+        TOMOYO_TYPE_IS_SYMLINK,      /* S_IFLNK */
+        TOMOYO_TYPE_IS_FILE,         /* S_IFREG */
+        TOMOYO_TYPE_IS_BLOCK_DEV,    /* S_IFBLK */
+        TOMOYO_TYPE_IS_DIRECTORY,    /* S_IFDIR */
+        TOMOYO_TYPE_IS_CHAR_DEV,     /* S_IFCHR */
+        TOMOYO_TYPE_IS_FIFO,         /* S_IFIFO */
+        TOMOYO_MODE_SETUID,          /* S_ISUID */
+        TOMOYO_MODE_SETGID,          /* S_ISGID */
+        TOMOYO_MODE_STICKY,          /* S_ISVTX */
+        TOMOYO_MODE_OWNER_READ,      /* S_IRUSR */
+        TOMOYO_MODE_OWNER_WRITE,     /* S_IWUSR */
+        TOMOYO_MODE_OWNER_EXECUTE,   /* S_IXUSR */
+        TOMOYO_MODE_GROUP_READ,      /* S_IRGRP */
+        TOMOYO_MODE_GROUP_WRITE,     /* S_IWGRP */
+        TOMOYO_MODE_GROUP_EXECUTE,   /* S_IXGRP */
+        TOMOYO_MODE_OTHERS_READ,     /* S_IROTH */
+        TOMOYO_MODE_OTHERS_WRITE,    /* S_IWOTH */
+        TOMOYO_MODE_OTHERS_EXECUTE,  /* S_IXOTH */
+        TOMOYO_EXEC_REALPATH,
+        TOMOYO_SYMLINK_TARGET,
+        TOMOYO_PATH1_UID,
+        TOMOYO_PATH1_GID,
+        TOMOYO_PATH1_INO,
+        TOMOYO_PATH1_MAJOR,
+        TOMOYO_PATH1_MINOR,
+        TOMOYO_PATH1_PERM,
+        TOMOYO_PATH1_TYPE,
+        TOMOYO_PATH1_DEV_MAJOR,
+        TOMOYO_PATH1_DEV_MINOR,
+        TOMOYO_PATH2_UID,
+        TOMOYO_PATH2_GID,
+        TOMOYO_PATH2_INO,
+        TOMOYO_PATH2_MAJOR,
+        TOMOYO_PATH2_MINOR,
+        TOMOYO_PATH2_PERM,
+        TOMOYO_PATH2_TYPE,
+        TOMOYO_PATH2_DEV_MAJOR,
+        TOMOYO_PATH2_DEV_MINOR,
+        TOMOYO_PATH1_PARENT_UID,
+        TOMOYO_PATH1_PARENT_GID,
+        TOMOYO_PATH1_PARENT_INO,
+        TOMOYO_PATH1_PARENT_PERM,
+        TOMOYO_PATH2_PARENT_UID,
+        TOMOYO_PATH2_PARENT_GID,
+        TOMOYO_PATH2_PARENT_INO,
+        TOMOYO_PATH2_PARENT_PERM,
+        TOMOYO_MAX_CONDITION_KEYWORD,
+        TOMOYO_NUMBER_UNION,
+        TOMOYO_NAME_UNION,
+        TOMOYO_ARGV_ENTRY,
+        TOMOYO_ENVP_ENTRY,
+};
+
+
+/* Index numbers for stat(). */
+enum tomoyo_path_stat_index {
+        /* Do not change this order. */
+        TOMOYO_PATH1,
+        TOMOYO_PATH1_PARENT,
+        TOMOYO_PATH2,
+        TOMOYO_PATH2_PARENT,
+        TOMOYO_MAX_PATH_STAT
+};
+
+/* Index numbers for operation mode. */
 enum tomoyo_mode_index {
         TOMOYO_CONFIG_DISABLED,
         TOMOYO_CONFIG_LEARNING,
         TOMOYO_CONFIG_PERMISSIVE,
         TOMOYO_CONFIG_ENFORCING,
-        TOMOYO_CONFIG_USE_DEFAULT = 255
+        TOMOYO_CONFIG_MAX_MODE,
+        TOMOYO_CONFIG_WANT_REJECT_LOG =  64,
+        TOMOYO_CONFIG_WANT_GRANT_LOG  = 128,
+        TOMOYO_CONFIG_USE_DEFAULT     = 255,
 };
 
+/* Index numbers for entry type. */
 enum tomoyo_policy_id {
         TOMOYO_ID_GROUP,
         TOMOYO_ID_PATH_GROUP,
         TOMOYO_ID_NUMBER_GROUP,
         TOMOYO_ID_TRANSITION_CONTROL,
         TOMOYO_ID_AGGREGATOR,
-        TOMOYO_ID_GLOBALLY_READABLE,
-        TOMOYO_ID_PATTERN,
-        TOMOYO_ID_NO_REWRITE,
         TOMOYO_ID_MANAGER,
+        TOMOYO_ID_CONDITION,
         TOMOYO_ID_NAME,
         TOMOYO_ID_ACL,
         TOMOYO_ID_DOMAIN,
         TOMOYO_MAX_POLICY
 };
 
+/* Index numbers for domain's attributes. */
+enum tomoyo_domain_info_flags_index {
+        /* Quota warnning flag.   */
+        TOMOYO_DIF_QUOTA_WARNED,
+        /*
+         * This domain was unable to create a new domain at
+         * tomoyo_find_next_domain() because the name of the domain to be
+         * created was too long or it could not allocate memory.
+         * More than one process continued execve() without domain transition.
+         */
+        TOMOYO_DIF_TRANSITION_FAILED,
+        TOMOYO_MAX_DOMAIN_INFO_FLAGS
+};
+
+/* Index numbers for group entries. */
 enum tomoyo_group_id {
         TOMOYO_PATH_GROUP,
         TOMOYO_NUMBER_GROUP,
         TOMOYO_MAX_GROUP
 };
 
-/* Keywords for ACLs. */
-#define TOMOYO_KEYWORD_AGGREGATOR                "aggregator "
-#define TOMOYO_KEYWORD_ALLOW_MOUNT               "allow_mount "
-#define TOMOYO_KEYWORD_ALLOW_READ                "allow_read "
-#define TOMOYO_KEYWORD_DELETE                    "delete "
-#define TOMOYO_KEYWORD_DENY_REWRITE              "deny_rewrite "
-#define TOMOYO_KEYWORD_FILE_PATTERN              "file_pattern "
-#define TOMOYO_KEYWORD_INITIALIZE_DOMAIN         "initialize_domain "
-#define TOMOYO_KEYWORD_KEEP_DOMAIN               "keep_domain "
-#define TOMOYO_KEYWORD_NO_INITIALIZE_DOMAIN      "no_initialize_domain "
-#define TOMOYO_KEYWORD_NO_KEEP_DOMAIN            "no_keep_domain "
-#define TOMOYO_KEYWORD_PATH_GROUP                "path_group "
-#define TOMOYO_KEYWORD_NUMBER_GROUP              "number_group "
-#define TOMOYO_KEYWORD_SELECT                    "select "
-#define TOMOYO_KEYWORD_USE_PROFILE               "use_profile "
-#define TOMOYO_KEYWORD_IGNORE_GLOBAL_ALLOW_READ  "ignore_global_allow_read"
-#define TOMOYO_KEYWORD_QUOTA_EXCEEDED            "quota_exceeded"
-#define TOMOYO_KEYWORD_TRANSITION_FAILED         "transition_failed"
-/* A domain definition starts with <kernel>. */
-#define TOMOYO_ROOT_NAME                         "<kernel>"
-#define TOMOYO_ROOT_NAME_LEN                     (sizeof(TOMOYO_ROOT_NAME) - 1)
-
-/* Value type definition. */
-#define TOMOYO_VALUE_TYPE_INVALID     0
-#define TOMOYO_VALUE_TYPE_DECIMAL     1
-#define TOMOYO_VALUE_TYPE_OCTAL       2
-#define TOMOYO_VALUE_TYPE_HEXADECIMAL 3
+/* Index numbers for type of numeric values. */
+enum tomoyo_value_type {
+        TOMOYO_VALUE_TYPE_INVALID,
+        TOMOYO_VALUE_TYPE_DECIMAL,
+        TOMOYO_VALUE_TYPE_OCTAL,
+        TOMOYO_VALUE_TYPE_HEXADECIMAL,
+};
 
+/* Index numbers for domain transition control keywords. */
 enum tomoyo_transition_type {
         /* Do not change this order, */
+        TOMOYO_TRANSITION_CONTROL_NO_RESET,
+        TOMOYO_TRANSITION_CONTROL_RESET,
         TOMOYO_TRANSITION_CONTROL_NO_INITIALIZE,
         TOMOYO_TRANSITION_CONTROL_INITIALIZE,
         TOMOYO_TRANSITION_CONTROL_NO_KEEP,
@@ -114,35 +198,29 @@ enum tomoyo_acl_entry_type_index {
         TOMOYO_TYPE_MOUNT_ACL,
 };
 
-/* Index numbers for File Controls. */
-
-/*
- * TOMOYO_TYPE_READ_WRITE is special. TOMOYO_TYPE_READ_WRITE is automatically
- * set if both TOMOYO_TYPE_READ and TOMOYO_TYPE_WRITE are set.
- * Both TOMOYO_TYPE_READ and TOMOYO_TYPE_WRITE are automatically set if
- * TOMOYO_TYPE_READ_WRITE is set.
- * TOMOYO_TYPE_READ_WRITE is automatically cleared if either TOMOYO_TYPE_READ
- * or TOMOYO_TYPE_WRITE is cleared.
- * Both TOMOYO_TYPE_READ and TOMOYO_TYPE_WRITE are automatically cleared if
- * TOMOYO_TYPE_READ_WRITE is cleared.
- */
-
+/* Index numbers for access controls with one pathname. */
 enum tomoyo_path_acl_index {
-        TOMOYO_TYPE_READ_WRITE,
         TOMOYO_TYPE_EXECUTE,
         TOMOYO_TYPE_READ,
         TOMOYO_TYPE_WRITE,
+        TOMOYO_TYPE_APPEND,
         TOMOYO_TYPE_UNLINK,
+        TOMOYO_TYPE_GETATTR,
         TOMOYO_TYPE_RMDIR,
         TOMOYO_TYPE_TRUNCATE,
         TOMOYO_TYPE_SYMLINK,
-        TOMOYO_TYPE_REWRITE,
         TOMOYO_TYPE_CHROOT,
         TOMOYO_TYPE_UMOUNT,
         TOMOYO_MAX_PATH_OPERATION
 };
 
-#define TOMOYO_RW_MASK ((1 << TOMOYO_TYPE_READ) | (1 << TOMOYO_TYPE_WRITE))
+/* Index numbers for /sys/kernel/security/tomoyo/stat interface. */
+enum tomoyo_memory_stat_type {
+        TOMOYO_MEMORY_POLICY,
+        TOMOYO_MEMORY_AUDIT,
+        TOMOYO_MEMORY_QUERY,
+        TOMOYO_MAX_MEMORY_STAT
+};
 
 enum tomoyo_mkdev_acl_index {
         TOMOYO_TYPE_MKBLOCK,
@@ -150,6 +228,7 @@ enum tomoyo_mkdev_acl_index {
         TOMOYO_MAX_MKDEV_OPERATION
 };
 
+/* Index numbers for access controls with two pathnames. */
 enum tomoyo_path2_acl_index {
         TOMOYO_TYPE_LINK,
         TOMOYO_TYPE_RENAME,
@@ -157,6 +236,7 @@ enum tomoyo_path2_acl_index {
         TOMOYO_MAX_PATH2_OPERATION
 };
 
+/* Index numbers for access controls with one pathname and one number. */
 enum tomoyo_path_number_acl_index {
         TOMOYO_TYPE_CREATE,
         TOMOYO_TYPE_MKDIR,
@@ -169,31 +249,45 @@ enum tomoyo_path_number_acl_index {
         TOMOYO_MAX_PATH_NUMBER_OPERATION
 };
 
+/* Index numbers for /sys/kernel/security/tomoyo/ interfaces. */
 enum tomoyo_securityfs_interface_index {
         TOMOYO_DOMAINPOLICY,
         TOMOYO_EXCEPTIONPOLICY,
-        TOMOYO_DOMAIN_STATUS,
         TOMOYO_PROCESS_STATUS,
-        TOMOYO_MEMINFO,
+        TOMOYO_STAT,
         TOMOYO_SELFDOMAIN,
+        TOMOYO_AUDIT,
         TOMOYO_VERSION,
         TOMOYO_PROFILE,
         TOMOYO_QUERY,
         TOMOYO_MANAGER
 };
 
+/* Index numbers for special mount operations. */
+enum tomoyo_special_mount {
+        TOMOYO_MOUNT_BIND,            /* mount --bind /source /dest   */
+        TOMOYO_MOUNT_MOVE,            /* mount --move /old /new       */
+        TOMOYO_MOUNT_REMOUNT,         /* mount -o remount /dir        */
+        TOMOYO_MOUNT_MAKE_UNBINDABLE, /* mount --make-unbindable /dir */
+        TOMOYO_MOUNT_MAKE_PRIVATE,    /* mount --make-private /dir    */
+        TOMOYO_MOUNT_MAKE_SLAVE,      /* mount --make-slave /dir      */
+        TOMOYO_MOUNT_MAKE_SHARED,     /* mount --make-shared /dir     */
+        TOMOYO_MAX_SPECIAL_MOUNT
+};
+
+/* Index numbers for functionality. */
 enum tomoyo_mac_index {
         TOMOYO_MAC_FILE_EXECUTE,
         TOMOYO_MAC_FILE_OPEN,
         TOMOYO_MAC_FILE_CREATE,
         TOMOYO_MAC_FILE_UNLINK,
+        TOMOYO_MAC_FILE_GETATTR,
         TOMOYO_MAC_FILE_MKDIR,
         TOMOYO_MAC_FILE_RMDIR,
         TOMOYO_MAC_FILE_MKFIFO,
         TOMOYO_MAC_FILE_MKSOCK,
         TOMOYO_MAC_FILE_TRUNCATE,
         TOMOYO_MAC_FILE_SYMLINK,
-        TOMOYO_MAC_FILE_REWRITE,
         TOMOYO_MAC_FILE_MKBLOCK,
         TOMOYO_MAC_FILE_MKCHAR,
         TOMOYO_MAC_FILE_LINK,
@@ -209,38 +303,66 @@ enum tomoyo_mac_index {
         TOMOYO_MAX_MAC_INDEX
 };
 
+/* Index numbers for category of functionality. */
 enum tomoyo_mac_category_index {
         TOMOYO_MAC_CATEGORY_FILE,
         TOMOYO_MAX_MAC_CATEGORY_INDEX
 };
 
-#define TOMOYO_RETRY_REQUEST 1 /* Retry this request. */
-
-/********** Structure definitions. **********/
-
 /*
- * tomoyo_acl_head is a structure which is used for holding elements not in
- * domain policy.
- * It has following fields.
+ * Retry this request. Returned by tomoyo_supervisor() if policy violation has
+ * occurred in enforcing mode and the userspace daemon decided to retry.
  *
- *  (1) "list" which is linked to tomoyo_policy_list[] .
- *  (2) "is_deleted" is a bool which is true if marked as deleted, false
- *      otherwise.
+ * We must choose a positive value in order to distinguish "granted" (which is
+ * 0) and "rejected" (which is a negative value) and "retry".
  */
+#define TOMOYO_RETRY_REQUEST 1
+
+/* Index numbers for /sys/kernel/security/tomoyo/stat interface. */
+enum tomoyo_policy_stat_type {
+        /* Do not change this order. */
+        TOMOYO_STAT_POLICY_UPDATES,
+        TOMOYO_STAT_POLICY_LEARNING,   /* == TOMOYO_CONFIG_LEARNING */
+        TOMOYO_STAT_POLICY_PERMISSIVE, /* == TOMOYO_CONFIG_PERMISSIVE */
+        TOMOYO_STAT_POLICY_ENFORCING,  /* == TOMOYO_CONFIG_ENFORCING */
+        TOMOYO_MAX_POLICY_STAT
+};
+
+/* Index numbers for profile's PREFERENCE values. */
+enum tomoyo_pref_index {
+        TOMOYO_PREF_MAX_AUDIT_LOG,
+        TOMOYO_PREF_MAX_LEARNING_ENTRY,
+        TOMOYO_MAX_PREF
+};
+
+/********** Structure definitions. **********/
+
+/* Common header for holding ACL entries. */
 struct tomoyo_acl_head {
         struct list_head list;
         bool is_deleted;
 } __packed;
 
-/*
- * tomoyo_request_info is a structure which is used for holding
- *
- * (1) Domain information of current process.
- * (2) How many retries are made for this request.
- * (3) Profile number used for this request.
- * (4) Access control mode of the profile.
- */
+/* Common header for shared entries. */
+struct tomoyo_shared_acl_head {
+        struct list_head list;
+        atomic_t users;
+} __packed;
+
+struct tomoyo_policy_namespace;
+
+/* Structure for request info. */
 struct tomoyo_request_info {
+        /*
+         * For holding parameters specific to operations which deal files.
+         * NULL if not dealing files.
+         */
+        struct tomoyo_obj_info *obj;
+        /*
+         * For holding parameters specific to execve() request.
+         * NULL if not dealing do_execve().
+         */
+        struct tomoyo_execve *ee;
         struct tomoyo_domain_info *domain;
         /* For holding parameters. */
         union {
@@ -248,11 +370,13 @@ struct tomoyo_request_info {
                         const struct tomoyo_path_info *filename;
                         /* For using wildcards at tomoyo_find_next_domain(). */
                         const struct tomoyo_path_info *matched_path;
+                        /* One of values in "enum tomoyo_path_acl_index". */
                         u8 operation;
                 } path;
                 struct {
                         const struct tomoyo_path_info *filename1;
                         const struct tomoyo_path_info *filename2;
+                        /* One of values in "enum tomoyo_path2_acl_index". */
                         u8 operation;
                 } path2;
                 struct {
@@ -260,11 +384,16 @@ struct tomoyo_request_info {
                         unsigned int mode;
                         unsigned int major;
                         unsigned int minor;
+                        /* One of values in "enum tomoyo_mkdev_acl_index". */
                         u8 operation;
                 } mkdev;
                 struct {
                         const struct tomoyo_path_info *filename;
                         unsigned long number;
+                        /*
+                         * One of values in
+                         * "enum tomoyo_path_number_acl_index".
+                         */
                         u8 operation;
                 } path_number;
                 struct {
@@ -283,26 +412,7 @@ struct tomoyo_request_info {
         u8 type;
 };
 
-/*
- * tomoyo_path_info is a structure which is used for holding a string data
- * used by TOMOYO.
- * This structure has several fields for supporting pattern matching.
- *
- * (1) "name" is the '\0' terminated string data.
- * (2) "hash" is full_name_hash(name, strlen(name)).
- *     This allows tomoyo_pathcmp() to compare by hash before actually compare
- *     using strcmp().
- * (3) "const_len" is the length of the initial segment of "name" which
- *     consists entirely of non wildcard characters. In other words, the length
- *     which we can compare two strings using strncmp().
- * (4) "is_dir" is a bool which is true if "name" ends with "/",
- *     false otherwise.
- *     TOMOYO distinguishes directory and non-directory. A directory ends with
- *     "/" and non-directory does not end with "/".
- * (5) "is_patterned" is a bool which is true if "name" contains wildcard
- *     characters, false otherwise. This allows TOMOYO to use "hash" and
- *     strcmp() for string comparison if "is_patterned" is false.
- */
+/* Structure for holding a token. */
 struct tomoyo_path_info {
         const char *name;
         u32 hash;          /* = full_name_hash(name, strlen(name)) */
@@ -311,36 +421,32 @@ struct tomoyo_path_info {
         bool is_patterned; /* = tomoyo_path_contains_pattern(name) */
 };
 
-/*
- * tomoyo_name is a structure which is used for linking
- * "struct tomoyo_path_info" into tomoyo_name_list .
- */
+/* Structure for holding string data. */
 struct tomoyo_name {
-        struct list_head list;
-        atomic_t users;
+        struct tomoyo_shared_acl_head head;
         struct tomoyo_path_info entry;
 };
 
+/* Structure for holding a word. */
 struct tomoyo_name_union {
+        /* Either @filename or @group is NULL. */
         const struct tomoyo_path_info *filename;
         struct tomoyo_group *group;
-        u8 is_group;
 };
 
+/* Structure for holding a number. */
 struct tomoyo_number_union {
         unsigned long values[2];
-        struct tomoyo_group *group;
-        u8 min_type;
-        u8 max_type;
-        u8 is_group;
+        struct tomoyo_group *group; /* Maybe NULL. */
+        /* One of values in "enum tomoyo_value_type". */
+        u8 value_type[2];
 };
 
 /* Structure for "path_group"/"number_group" directive. */
 struct tomoyo_group {
-        struct list_head list;
+        struct tomoyo_shared_acl_head head;
         const struct tomoyo_path_info *group_name;
         struct list_head member_list;
-        atomic_t users;
 };
 
 /* Structure for "path_group" directive. */
@@ -355,130 +461,158 @@ struct tomoyo_number_group {
         struct tomoyo_number_union number;
 };
 
-/*
- * tomoyo_acl_info is a structure which is used for holding
- *
- *  (1) "list" which is linked to the ->acl_info_list of
- *      "struct tomoyo_domain_info"
- *  (2) "is_deleted" is a bool which is true if this domain is marked as
- *      "deleted", false otherwise.
- *  (3) "type" which tells type of the entry.
- *
- * Packing "struct tomoyo_acl_info" allows
- * "struct tomoyo_path_acl" to embed "u16" and "struct tomoyo_path2_acl"
- * "struct tomoyo_path_number_acl" "struct tomoyo_mkdev_acl" to embed
- * "u8" without enlarging their structure size.
- */
+/* Subset of "struct stat". Used by conditional ACL and audit logs. */
+struct tomoyo_mini_stat {
+        uid_t uid;
+        gid_t gid;
+        ino_t ino;
+        mode_t mode;
+        dev_t dev;
+        dev_t rdev;
+};
+
+/* Structure for dumping argv[] and envp[] of "struct linux_binprm". */
+struct tomoyo_page_dump {
+        struct page *page;    /* Previously dumped page. */
+        char *data;           /* Contents of "page". Size is PAGE_SIZE. */
+};
+
+/* Structure for attribute checks in addition to pathname checks. */
+struct tomoyo_obj_info {
+        /*
+         * True if tomoyo_get_attributes() was already called, false otherwise.
+         */
+        bool validate_done;
+        /* True if @stat[] is valid. */
+        bool stat_valid[TOMOYO_MAX_PATH_STAT];
+        /* First pathname. Initialized with { NULL, NULL } if no path. */
+        struct path path1;
+        /* Second pathname. Initialized with { NULL, NULL } if no path. */
+        struct path path2;
+        /*
+         * Information on @path1, @path1's parent directory, @path2, @path2's
+         * parent directory.
+         */
+        struct tomoyo_mini_stat stat[TOMOYO_MAX_PATH_STAT];
+        /*
+         * Content of symbolic link to be created. NULL for operations other
+         * than symlink().
+         */
+        struct tomoyo_path_info *symlink_target;
+};
+
+/* Structure for argv[]. */
+struct tomoyo_argv {
+        unsigned long index;
+        const struct tomoyo_path_info *value;
+        bool is_not;
+};
+
+/* Structure for envp[]. */
+struct tomoyo_envp {
+        const struct tomoyo_path_info *name;
+        const struct tomoyo_path_info *value;
+        bool is_not;
+};
+
+/* Structure for execve() operation. */
+struct tomoyo_execve {
+        struct tomoyo_request_info r;
+        struct tomoyo_obj_info obj;
+        struct linux_binprm *bprm;
+        /* For dumping argv[] and envp[]. */
+        struct tomoyo_page_dump dump;
+        /* For temporary use. */
+        char *tmp; /* Size is TOMOYO_EXEC_TMPSIZE bytes */
+};
+
+/* Structure for entries which follows "struct tomoyo_condition". */
+struct tomoyo_condition_element {
+        /*
+         * Left hand operand. A "struct tomoyo_argv" for TOMOYO_ARGV_ENTRY, a
+         * "struct tomoyo_envp" for TOMOYO_ENVP_ENTRY is attached to the tail
+         * of the array of this struct.
+         */
+        u8 left;
+        /*
+         * Right hand operand. A "struct tomoyo_number_union" for
+         * TOMOYO_NUMBER_UNION, a "struct tomoyo_name_union" for
+         * TOMOYO_NAME_UNION is attached to the tail of the array of this
+         * struct.
+         */
+        u8 right;
+        /* Equation operator. True if equals or overlaps, false otherwise. */
+        bool equals;
+};
+
+/* Structure for optional arguments. */
+struct tomoyo_condition {
+        struct tomoyo_shared_acl_head head;
+        u32 size; /* Memory size allocated for this entry. */
+        u16 condc; /* Number of conditions in this struct. */
+        u16 numbers_count; /* Number of "struct tomoyo_number_union values". */
+        u16 names_count; /* Number of "struct tomoyo_name_union names". */
+        u16 argc; /* Number of "struct tomoyo_argv". */
+        u16 envc; /* Number of "struct tomoyo_envp". */
+        /*
+         * struct tomoyo_condition_element condition[condc];
+         * struct tomoyo_number_union values[numbers_count];
+         * struct tomoyo_name_union names[names_count];
+         * struct tomoyo_argv argv[argc];
+         * struct tomoyo_envp envp[envc];
+         */
+};
+
+/* Common header for individual entries. */
 struct tomoyo_acl_info {
         struct list_head list;
+        struct tomoyo_condition *cond; /* Maybe NULL. */
         bool is_deleted;
-        u8 type; /* = one of values in "enum tomoyo_acl_entry_type_index". */
+        u8 type; /* One of values in "enum tomoyo_acl_entry_type_index". */
 } __packed;
 
-/*
- * tomoyo_domain_info is a structure which is used for holding permissions
- * (e.g. "allow_read /lib/libc-2.5.so") given to each domain.
- * It has following fields.
- *
- *  (1) "list" which is linked to tomoyo_domain_list .
- *  (2) "acl_info_list" which is linked to "struct tomoyo_acl_info".
- *  (3) "domainname" which holds the name of the domain.
- *  (4) "profile" which remembers profile number assigned to this domain.
- *  (5) "is_deleted" is a bool which is true if this domain is marked as
- *      "deleted", false otherwise.
- *  (6) "quota_warned" is a bool which is used for suppressing warning message
- *      when learning mode learned too much entries.
- *  (7) "ignore_global_allow_read" is a bool which is true if this domain
- *      should ignore "allow_read" directive in exception policy.
- *  (8) "transition_failed" is a bool which is set to true when this domain was
- *      unable to create a new domain at tomoyo_find_next_domain() because the
- *      name of the domain to be created was too long or it could not allocate
- *      memory. If set to true, more than one process continued execve()
- *      without domain transition.
- *  (9) "users" is an atomic_t that holds how many "struct cred"->security
- *      are referring this "struct tomoyo_domain_info". If is_deleted == true
- *      and users == 0, this struct will be kfree()d upon next garbage
- *      collection.
- *
- * A domain's lifecycle is an analogy of files on / directory.
- * Multiple domains with the same domainname cannot be created (as with
- * creating files with the same filename fails with -EEXIST).
- * If a process reached a domain, that process can reside in that domain after
- * that domain is marked as "deleted" (as with a process can access an already
- * open()ed file after that file was unlink()ed).
- */
+/* Structure for domain information. */
 struct tomoyo_domain_info {
         struct list_head list;
         struct list_head acl_info_list;
         /* Name of this domain. Never NULL.          */
         const struct tomoyo_path_info *domainname;
+        /* Namespace for this domain. Never NULL. */
+        struct tomoyo_policy_namespace *ns;
         u8 profile;        /* Profile number to use. */
+        u8 group;          /* Group number to use.   */
         bool is_deleted;   /* Delete flag.           */
-        bool quota_warned; /* Quota warnning flag.   */
-        bool ignore_global_allow_read; /* Ignore "allow_read" flag. */
-        bool transition_failed; /* Domain transition failed flag. */
+        bool flags[TOMOYO_MAX_DOMAIN_INFO_FLAGS];
         atomic_t users; /* Number of referring credentials. */
 };
 
 /*
- * tomoyo_path_acl is a structure which is used for holding an
- * entry with one pathname operation (e.g. open(), mkdir()).
- * It has following fields.
- *
- *  (1) "head" which is a "struct tomoyo_acl_info".
- *  (2) "perm" which is a bitmask of permitted operations.
- *  (3) "name" is the pathname.
- *
- * Directives held by this structure are "allow_read/write", "allow_execute",
- * "allow_read", "allow_write", "allow_unlink", "allow_rmdir",
- * "allow_truncate", "allow_symlink", "allow_rewrite", "allow_chroot" and
- * "allow_unmount".
+ * Structure for "file execute", "file read", "file write", "file append",
+ * "file unlink", "file getattr", "file rmdir", "file truncate",
+ * "file symlink", "file chroot" and "file unmount" directive.
  */
 struct tomoyo_path_acl {
         struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_PATH_ACL */
-        u16 perm;
+        u16 perm; /* Bitmask of values in "enum tomoyo_path_acl_index". */
         struct tomoyo_name_union name;
 };
 
 /*
- * tomoyo_path_number_acl is a structure which is used for holding an
- * entry with one pathname and one number operation.
- * It has following fields.
- *
- *  (1) "head" which is a "struct tomoyo_acl_info".
- *  (2) "perm" which is a bitmask of permitted operations.
- *  (3) "name" is the pathname.
- *  (4) "number" is the numeric value.
- *
- * Directives held by this structure are "allow_create", "allow_mkdir",
- * "allow_ioctl", "allow_mkfifo", "allow_mksock", "allow_chmod", "allow_chown"
- * and "allow_chgrp".
- *
+ * Structure for "file create", "file mkdir", "file mkfifo", "file mksock",
+ * "file ioctl", "file chmod", "file chown" and "file chgrp" directive.
  */
 struct tomoyo_path_number_acl {
         struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_PATH_NUMBER_ACL */
+        /* Bitmask of values in "enum tomoyo_path_number_acl_index". */
         u8 perm;
         struct tomoyo_name_union name;
         struct tomoyo_number_union number;
 };
 
-/*
- * tomoyo_mkdev_acl is a structure which is used for holding an
- * entry with one pathname and three numbers operation.
- * It has following fields.
- *
- *  (1) "head" which is a "struct tomoyo_acl_info".
- *  (2) "perm" which is a bitmask of permitted operations.
- *  (3) "mode" is the create mode.
- *  (4) "major" is the major number of device node.
- *  (5) "minor" is the minor number of device node.
- *
- * Directives held by this structure are "allow_mkchar", "allow_mkblock".
- *
- */
+/* Structure for "file mkblock" and "file mkchar" directive. */
 struct tomoyo_mkdev_acl {
         struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_MKDEV_ACL */
-        u8 perm;
+        u8 perm; /* Bitmask of values in "enum tomoyo_mkdev_acl_index". */
         struct tomoyo_name_union name;
         struct tomoyo_number_union mode;
         struct tomoyo_number_union major;
@@ -486,38 +620,16 @@ struct tomoyo_mkdev_acl {
 };
 
 /*
- * tomoyo_path2_acl is a structure which is used for holding an
- * entry with two pathnames operation (i.e. link(), rename() and pivot_root()).
- * It has following fields.
- *
- *  (1) "head" which is a "struct tomoyo_acl_info".
- *  (2) "perm" which is a bitmask of permitted operations.
- *  (3) "name1" is the source/old pathname.
- *  (4) "name2" is the destination/new pathname.
- *
- * Directives held by this structure are "allow_rename", "allow_link" and
- * "allow_pivot_root".
+ * Structure for "file rename", "file link" and "file pivot_root" directive.
  */
 struct tomoyo_path2_acl {
         struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_PATH2_ACL */
-        u8 perm;
+        u8 perm; /* Bitmask of values in "enum tomoyo_path2_acl_index". */
         struct tomoyo_name_union name1;
         struct tomoyo_name_union name2;
 };
 
-/*
- * tomoyo_mount_acl is a structure which is used for holding an
- * entry for mount operation.
- * It has following fields.
- *
- *  (1) "head" which is a "struct tomoyo_acl_info".
- *  (2) "dev_name" is the device name.
- *  (3) "dir_name" is the mount point.
- *  (4) "fs_type" is the filesystem type.
- *  (5) "flags" is the mount flags.
- *
- * Directive held by this structure is "allow_mount".
- */
+/* Structure for "file mount" directive. */
 struct tomoyo_mount_acl {
         struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_MOUNT_ACL */
         struct tomoyo_name_union dev_name;
@@ -526,7 +638,15 @@ struct tomoyo_mount_acl {
         struct tomoyo_number_union flags;
 };
 
-#define TOMOYO_MAX_IO_READ_QUEUE 32
+/* Structure for holding a line from /sys/kernel/security/tomoyo/ interface. */
+struct tomoyo_acl_param {
+        char *data;
+        struct list_head *list;
+        struct tomoyo_policy_namespace *ns;
+        bool is_delete;
+};
+
+#define TOMOYO_MAX_IO_READ_QUEUE 64
 
 /*
  * Structure for reading/writing policy via /sys/kernel/security/tomoyo
@@ -538,95 +658,55 @@ struct tomoyo_io_buffer {
         int (*poll) (struct file *file, poll_table *wait);
         /* Exclusive lock for this structure.   */
         struct mutex io_sem;
-        /* Index returned by tomoyo_read_lock(). */
-        int reader_idx;
         char __user *read_user_buf;
-        int read_user_buf_avail;
+        size_t read_user_buf_avail;
         struct {
+                struct list_head *ns;
                 struct list_head *domain;
                 struct list_head *group;
                 struct list_head *acl;
-                int avail;
-                int step;
-                int query_index;
+                size_t avail;
+                unsigned int step;
+                unsigned int query_index;
                 u16 index;
+                u16 cond_index;
+                u8 acl_group_index;
+                u8 cond_step;
                 u8 bit;
                 u8 w_pos;
                 bool eof;
                 bool print_this_domain_only;
-                bool print_execute_only;
+                bool print_transition_related_only;
+                bool print_cond_part;
                 const char *w[TOMOYO_MAX_IO_READ_QUEUE];
         } r;
-        /* The position currently writing to.   */
-        struct tomoyo_domain_info *write_var1;
+        struct {
+                struct tomoyo_policy_namespace *ns;
+                /* The position currently writing to.   */
+                struct tomoyo_domain_info *domain;
+                /* Bytes available for writing.         */
+                size_t avail;
+                bool is_delete;
+        } w;
         /* Buffer for reading.                  */
         char *read_buf;
         /* Size of read buffer.                 */
-        int readbuf_size;
+        size_t readbuf_size;
         /* Buffer for writing.                  */
         char *write_buf;
-        /* Bytes available for writing.         */
-        int write_avail;
         /* Size of write buffer.                */
-        int writebuf_size;
+        size_t writebuf_size;
         /* Type of this interface.              */
-        u8 type;
-};
-
-/*
- * tomoyo_readable_file is a structure which is used for holding
- * "allow_read" entries.
- * It has following fields.
- *
- *  (1) "head" is "struct tomoyo_acl_head".
- *  (2) "filename" is a pathname which is allowed to open(O_RDONLY).
- */
-struct tomoyo_readable_file {
-        struct tomoyo_acl_head head;
-        const struct tomoyo_path_info *filename;
-};
-
-/*
- * tomoyo_no_pattern is a structure which is used for holding
- * "file_pattern" entries.
- * It has following fields.
- *
- *  (1) "head" is "struct tomoyo_acl_head".
- *  (2) "pattern" is a pathname pattern which is used for converting pathnames
- *      to pathname patterns during learning mode.
- */
-struct tomoyo_no_pattern {
-        struct tomoyo_acl_head head;
-        const struct tomoyo_path_info *pattern;
-};
-
-/*
- * tomoyo_no_rewrite is a structure which is used for holding
- * "deny_rewrite" entries.
- * It has following fields.
- *
- *  (1) "head" is "struct tomoyo_acl_head".
- *  (2) "pattern" is a pathname which is by default not permitted to modify
- *      already existing content.
- */
-struct tomoyo_no_rewrite {
-        struct tomoyo_acl_head head;
-        const struct tomoyo_path_info *pattern;
+        enum tomoyo_securityfs_interface_index type;
+        /* Users counter protected by tomoyo_io_buffer_list_lock. */
+        u8 users;
+        /* List for telling GC not to kfree() elements. */
+        struct list_head list;
 };
 
 /*
- * tomoyo_transition_control is a structure which is used for holding
- * "initialize_domain"/"no_initialize_domain"/"keep_domain"/"no_keep_domain"
- * entries.
- * It has following fields.
- *
- *  (1) "head" is "struct tomoyo_acl_head".
- *  (2) "type" is type of this entry.
- *  (3) "is_last_name" is a bool which is true if "domainname" is "the last
- *      component of a domainname", false otherwise.
- *  (4) "domainname" which is "a domainname" or "the last component of a
- *      domainname".
- *  (5) "program" which is a program's pathname.
+ * Structure for "initialize_domain"/"no_initialize_domain"/"keep_domain"/
+ * "no_keep_domain" keyword.
  */
 struct tomoyo_transition_control {
         struct tomoyo_acl_head head;
@@ -637,32 +717,14 @@ struct tomoyo_transition_control {
         const struct tomoyo_path_info *program;    /* Maybe NULL */
 };
 
-/*
- * tomoyo_aggregator is a structure which is used for holding
- * "aggregator" entries.
- * It has following fields.
- *
- *  (1) "head" is "struct tomoyo_acl_head".
- *  (2) "original_name" which is originally requested name.
- *  (3) "aggregated_name" which is name to rewrite.
- */
+/* Structure for "aggregator" keyword. */
 struct tomoyo_aggregator {
         struct tomoyo_acl_head head;
         const struct tomoyo_path_info *original_name;
         const struct tomoyo_path_info *aggregated_name;
 };
 
-/*
- * tomoyo_manager is a structure which is used for holding list of
- * domainnames or programs which are permitted to modify configuration via
- * /sys/kernel/security/tomoyo/ interface.
- * It has following fields.
- *
- *  (1) "head" is "struct tomoyo_acl_head".
- *  (2) "is_domain" is a bool which is true if "manager" is a domainname, false
- *      otherwise.
- *  (3) "manager" is a domainname or a program's pathname.
- */
+/* Structure for policy manager. */
 struct tomoyo_manager {
         struct tomoyo_acl_head head;
         bool is_domain;  /* True if manager is a domainname. */
@@ -677,6 +739,7 @@ struct tomoyo_preference {
         bool permissive_verbose;
 };
 
+/* Structure for /sys/kernel/security/tomnoyo/profile interface. */
 struct tomoyo_profile {
         const struct tomoyo_path_info *comment;
         struct tomoyo_preference *learning;
@@ -685,323 +748,409 @@ struct tomoyo_profile {
         struct tomoyo_preference preference;
         u8 default_config;
         u8 config[TOMOYO_MAX_MAC_INDEX + TOMOYO_MAX_MAC_CATEGORY_INDEX];
+        unsigned int pref[TOMOYO_MAX_PREF];
+};
+
+/* Structure for representing YYYY/MM/DD hh/mm/ss. */
+struct tomoyo_time {
+        u16 year;
+        u8 month;
+        u8 day;
+        u8 hour;
+        u8 min;
+        u8 sec;
+};
+
+/* Structure for policy namespace. */
+struct tomoyo_policy_namespace {
+        /* Profile table. Memory is allocated as needed. */
+        struct tomoyo_profile *profile_ptr[TOMOYO_MAX_PROFILES];
+        /* List of "struct tomoyo_group". */
+        struct list_head group_list[TOMOYO_MAX_GROUP];
+        /* List of policy. */
+        struct list_head policy_list[TOMOYO_MAX_POLICY];
+        /* The global ACL referred by "use_group" keyword. */
+        struct list_head acl_group[TOMOYO_MAX_ACL_GROUPS];
+        /* List for connecting to tomoyo_namespace_list list. */
+        struct list_head namespace_list;
+        /* Profile version. Currently only 20100903 is defined. */
+        unsigned int profile_version;
+        /* Name of this namespace (e.g. "<kernel>", "</usr/sbin/httpd>" ). */
+        const char *name;
 };
 
 /********** Function prototypes. **********/
 
-/* Check whether the given string starts with the given keyword. */
-bool tomoyo_str_starts(char **src, const char *find);
-/* Get tomoyo_realpath() of current process. */
-const char *tomoyo_get_exe(void);
-/* Format string. */
-void tomoyo_normalize_line(unsigned char *buffer);
-/* Print warning or error message on console. */
-void tomoyo_warn_log(struct tomoyo_request_info *r, const char *fmt, ...)
-     __attribute__ ((format(printf, 2, 3)));
-/* Check all profiles currently assigned to domains are defined. */
-void tomoyo_check_profile(void);
-/* Open operation for /sys/kernel/security/tomoyo/ interface. */
-int tomoyo_open_control(const u8 type, struct file *file);
-/* Close /sys/kernel/security/tomoyo/ interface. */
-int tomoyo_close_control(struct file *file);
-/* Poll operation for /sys/kernel/security/tomoyo/ interface. */
-int tomoyo_poll_control(struct file *file, poll_table *wait);
-/* Read operation for /sys/kernel/security/tomoyo/ interface. */
-int tomoyo_read_control(struct file *file, char __user *buffer,
-                        const int buffer_len);
-/* Write operation for /sys/kernel/security/tomoyo/ interface. */
-int tomoyo_write_control(struct file *file, const char __user *buffer,
-                         const int buffer_len);
-/* Check whether the domain has too many ACL entries to hold. */
-bool tomoyo_domain_quota_is_ok(struct tomoyo_request_info *r);
-/* Print out of memory warning message. */
-void tomoyo_warn_oom(const char *function);
-/* Check whether the given name matches the given name_union. */
-const struct tomoyo_path_info *
-tomoyo_compare_name_union(const struct tomoyo_path_info *name,
-                          const struct tomoyo_name_union *ptr);
-/* Check whether the given number matches the given number_union. */
 bool tomoyo_compare_number_union(const unsigned long value,
                                  const struct tomoyo_number_union *ptr);
-int tomoyo_get_mode(const u8 profile, const u8 index);
-void tomoyo_io_printf(struct tomoyo_io_buffer *head, const char *fmt, ...)
-        __attribute__ ((format(printf, 2, 3)));
-/* Check whether the domainname is correct. */
+bool tomoyo_condition(struct tomoyo_request_info *r,
+                      const struct tomoyo_condition *cond);
 bool tomoyo_correct_domain(const unsigned char *domainname);
-/* Check whether the token is correct. */
 bool tomoyo_correct_path(const char *filename);
 bool tomoyo_correct_word(const char *string);
-/* Check whether the token can be a domainname. */
 bool tomoyo_domain_def(const unsigned char *buffer);
-bool tomoyo_parse_name_union(const char *filename,
-                             struct tomoyo_name_union *ptr);
-/* Check whether the given filename matches the given path_group. */
-const struct tomoyo_path_info *
-tomoyo_path_matches_group(const struct tomoyo_path_info *pathname,
-                          const struct tomoyo_group *group);
-/* Check whether the given value matches the given number_group. */
+bool tomoyo_domain_quota_is_ok(struct tomoyo_request_info *r);
+bool tomoyo_dump_page(struct linux_binprm *bprm, unsigned long pos,
+                      struct tomoyo_page_dump *dump);
+bool tomoyo_memory_ok(void *ptr);
 bool tomoyo_number_matches_group(const unsigned long min,
                                  const unsigned long max,
                                  const struct tomoyo_group *group);
-/* Check whether the given filename matches the given pattern. */
+bool tomoyo_parse_name_union(struct tomoyo_acl_param *param,
+                             struct tomoyo_name_union *ptr);
+bool tomoyo_parse_number_union(struct tomoyo_acl_param *param,
+                               struct tomoyo_number_union *ptr);
 bool tomoyo_path_matches_pattern(const struct tomoyo_path_info *filename,
                                  const struct tomoyo_path_info *pattern);
-
-bool tomoyo_parse_number_union(char *data, struct tomoyo_number_union *num);
-/* Tokenize a line. */
-bool tomoyo_tokenize(char *buffer, char *w[], size_t size);
-/* Write domain policy violation warning message to console? */
-bool tomoyo_verbose_mode(const struct tomoyo_domain_info *domain);
-/* Fill "struct tomoyo_request_info". */
-int tomoyo_init_request_info(struct tomoyo_request_info *r,
-                             struct tomoyo_domain_info *domain,
-                             const u8 index);
-/* Check permission for mount operation. */
-int tomoyo_mount_permission(char *dev_name, struct path *path, char *type,
-                            unsigned long flags, void *data_page);
-/* Create "aggregator" entry in exception policy. */
-int tomoyo_write_aggregator(char *data, const bool is_delete);
-int tomoyo_write_transition_control(char *data, const bool is_delete,
-                                    const u8 type);
-/*
- * Create "allow_read/write", "allow_execute", "allow_read", "allow_write",
- * "allow_create", "allow_unlink", "allow_mkdir", "allow_rmdir",
- * "allow_mkfifo", "allow_mksock", "allow_mkblock", "allow_mkchar",
- * "allow_truncate", "allow_symlink", "allow_rewrite", "allow_rename" and
- * "allow_link" entry in domain policy.
- */
-int tomoyo_write_file(char *data, struct tomoyo_domain_info *domain,
-                      const bool is_delete);
-/* Create "allow_read" entry in exception policy. */
-int tomoyo_write_globally_readable(char *data, const bool is_delete);
-/* Create "allow_mount" entry in domain policy. */
-int tomoyo_write_mount(char *data, struct tomoyo_domain_info *domain,
-                       const bool is_delete);
-/* Create "deny_rewrite" entry in exception policy. */
-int tomoyo_write_no_rewrite(char *data, const bool is_delete);
-/* Create "file_pattern" entry in exception policy. */
-int tomoyo_write_pattern(char *data, const bool is_delete);
-/* Create "path_group"/"number_group" entry in exception policy. */
-int tomoyo_write_group(char *data, const bool is_delete, const u8 type);
-int tomoyo_supervisor(struct tomoyo_request_info *r, const char *fmt, ...)
-     __attribute__ ((format(printf, 2, 3)));
-/* Find a domain by the given name. */
-struct tomoyo_domain_info *tomoyo_find_domain(const char *domainname);
-/* Find or create a domain by the given name. */
-struct tomoyo_domain_info *tomoyo_assign_domain(const char *domainname,
-                                                const u8 profile);
-struct tomoyo_profile *tomoyo_profile(const u8 profile);
-/*
- * Allocate memory for "struct tomoyo_path_group"/"struct tomoyo_number_group".
- */
-struct tomoyo_group *tomoyo_get_group(const char *group_name, const u8 type);
-
-/* Check mode for specified functionality. */
-unsigned int tomoyo_check_flags(const struct tomoyo_domain_info *domain,
-                                const u8 index);
-/* Fill in "struct tomoyo_path_info" members. */
-void tomoyo_fill_path_info(struct tomoyo_path_info *ptr);
-/* Run policy loader when /sbin/init starts. */
-void tomoyo_load_policy(const char *filename);
-
-void tomoyo_put_number_union(struct tomoyo_number_union *ptr);
-
-/* Convert binary string to ascii string. */
+bool tomoyo_permstr(const char *string, const char *keyword);
+bool tomoyo_str_starts(char **src, const char *find);
 char *tomoyo_encode(const char *str);
-
-/*
- * Returns realpath(3) of the given pathname except that
- * ignores chroot'ed root and does not follow the final symlink.
- */
-char *tomoyo_realpath_nofollow(const char *pathname);
-/*
- * Returns realpath(3) of the given pathname except that
- * ignores chroot'ed root and the pathname is already solved.
- */
+char *tomoyo_init_log(struct tomoyo_request_info *r, int len, const char *fmt,
+                      va_list args);
+char *tomoyo_read_token(struct tomoyo_acl_param *param);
 char *tomoyo_realpath_from_path(struct path *path);
-/* Get patterned pathname. */
-const char *tomoyo_pattern(const struct tomoyo_path_info *filename);
-
-/* Check memory quota. */
-bool tomoyo_memory_ok(void *ptr);
-void *tomoyo_commit_ok(void *data, const unsigned int size);
-
-/*
- * Keep the given name on the RAM.
- * The RAM is shared, so NEVER try to modify or kfree() the returned name.
- */
+char *tomoyo_realpath_nofollow(const char *pathname);
+const char *tomoyo_get_exe(void);
+const char *tomoyo_yesno(const unsigned int value);
+const struct tomoyo_path_info *tomoyo_compare_name_union
+(const struct tomoyo_path_info *name, const struct tomoyo_name_union *ptr);
 const struct tomoyo_path_info *tomoyo_get_name(const char *name);
-
-/* Check for memory usage. */
-void tomoyo_read_memory_counter(struct tomoyo_io_buffer *head);
-
-/* Set memory quota. */
-int tomoyo_write_memory_quota(struct tomoyo_io_buffer *head);
-
-/* Initialize mm related code. */
-void __init tomoyo_mm_init(void);
-int tomoyo_path_permission(struct tomoyo_request_info *r, u8 operation,
-                           const struct tomoyo_path_info *filename);
+const struct tomoyo_path_info *tomoyo_path_matches_group
+(const struct tomoyo_path_info *pathname, const struct tomoyo_group *group);
 int tomoyo_check_open_permission(struct tomoyo_domain_info *domain,
                                  struct path *path, const int flag);
-int tomoyo_path_number_perm(const u8 operation, struct path *path,
-                            unsigned long number);
+int tomoyo_close_control(struct tomoyo_io_buffer *head);
+int tomoyo_find_next_domain(struct linux_binprm *bprm);
+int tomoyo_get_mode(const struct tomoyo_policy_namespace *ns, const u8 profile,
+                    const u8 index);
+int tomoyo_init_request_info(struct tomoyo_request_info *r,
+                             struct tomoyo_domain_info *domain,
+                             const u8 index);
 int tomoyo_mkdev_perm(const u8 operation, struct path *path,
                       const unsigned int mode, unsigned int dev);
-int tomoyo_path_perm(const u8 operation, struct path *path);
+int tomoyo_mount_permission(char *dev_name, struct path *path,
+                            const char *type, unsigned long flags,
+                            void *data_page);
+int tomoyo_open_control(const u8 type, struct file *file);
 int tomoyo_path2_perm(const u8 operation, struct path *path1,
                       struct path *path2);
-int tomoyo_find_next_domain(struct linux_binprm *bprm);
-
-void tomoyo_print_ulong(char *buffer, const int buffer_len,
-                        const unsigned long value, const u8 type);
-
-/* Drop refcount on tomoyo_name_union. */
-void tomoyo_put_name_union(struct tomoyo_name_union *ptr);
-
-/* Run garbage collector. */
-void tomoyo_run_gc(void);
-
-void tomoyo_memory_free(void *ptr);
-
+int tomoyo_path_number_perm(const u8 operation, struct path *path,
+                            unsigned long number);
+int tomoyo_path_perm(const u8 operation, struct path *path,
+                     const char *target);
+int tomoyo_path_permission(struct tomoyo_request_info *r, u8 operation,
+                           const struct tomoyo_path_info *filename);
+int tomoyo_poll_control(struct file *file, poll_table *wait);
+int tomoyo_poll_log(struct file *file, poll_table *wait);
+int tomoyo_supervisor(struct tomoyo_request_info *r, const char *fmt, ...)
+        __printf(2, 3);
 int tomoyo_update_domain(struct tomoyo_acl_info *new_entry, const int size,
-                         bool is_delete, struct tomoyo_domain_info *domain,
-                         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));
+                         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));
 int tomoyo_update_policy(struct tomoyo_acl_head *new_entry, const int size,
-                         bool is_delete, struct list_head *list,
-                         bool (*check_duplicate) (const struct tomoyo_acl_head
-                                                  *,
-                                                  const struct tomoyo_acl_head
-                                                  *));
+                         struct tomoyo_acl_param *param,
+                         bool (*check_duplicate)
+                         (const struct tomoyo_acl_head *,
+                          const struct tomoyo_acl_head *));
+int tomoyo_write_aggregator(struct tomoyo_acl_param *param);
+int tomoyo_write_file(struct tomoyo_acl_param *param);
+int tomoyo_write_group(struct tomoyo_acl_param *param, const u8 type);
+int tomoyo_write_transition_control(struct tomoyo_acl_param *param,
+                                    const u8 type);
+ssize_t tomoyo_read_control(struct tomoyo_io_buffer *head, char __user *buffer,
+                            const int buffer_len);
+ssize_t tomoyo_write_control(struct tomoyo_io_buffer *head,
+                             const char __user *buffer, const int buffer_len);
+struct tomoyo_condition *tomoyo_get_condition(struct tomoyo_acl_param *param);
+struct tomoyo_domain_info *tomoyo_assign_domain(const char *domainname,
+                                                const bool transit);
+struct tomoyo_domain_info *tomoyo_find_domain(const char *domainname);
+struct tomoyo_group *tomoyo_get_group(struct tomoyo_acl_param *param,
+                                      const u8 idx);
+struct tomoyo_policy_namespace *tomoyo_assign_namespace
+(const char *domainname);
+struct tomoyo_profile *tomoyo_profile(const struct tomoyo_policy_namespace *ns,
+                                      const u8 profile);
+unsigned int tomoyo_check_flags(const struct tomoyo_domain_info *domain,
+                                const u8 index);
+u8 tomoyo_parse_ulong(unsigned long *result, char **str);
+void *tomoyo_commit_ok(void *data, const unsigned int size);
+void __init tomoyo_load_builtin_policy(void);
+void __init tomoyo_mm_init(void);
 void tomoyo_check_acl(struct tomoyo_request_info *r,
                       bool (*check_entry) (struct tomoyo_request_info *,
                                            const struct tomoyo_acl_info *));
+void tomoyo_check_profile(void);
+void tomoyo_convert_time(time_t time, struct tomoyo_time *stamp);
+void tomoyo_del_condition(struct list_head *element);
+void tomoyo_fill_path_info(struct tomoyo_path_info *ptr);
+void tomoyo_get_attributes(struct tomoyo_obj_info *obj);
+void tomoyo_init_policy_namespace(struct tomoyo_policy_namespace *ns);
+void tomoyo_io_printf(struct tomoyo_io_buffer *head, const char *fmt, ...)
+         __printf(2, 3);
+void tomoyo_load_policy(const char *filename);
+void tomoyo_memory_free(void *ptr);
+void tomoyo_normalize_line(unsigned char *buffer);
+void tomoyo_notify_gc(struct tomoyo_io_buffer *head, const bool is_register);
+void tomoyo_print_ulong(char *buffer, const int buffer_len,
+                        const unsigned long value, const u8 type);
+void tomoyo_put_name_union(struct tomoyo_name_union *ptr);
+void tomoyo_put_number_union(struct tomoyo_number_union *ptr);
+void tomoyo_read_log(struct tomoyo_io_buffer *head);
+void tomoyo_update_stat(const u8 index);
+void tomoyo_warn_oom(const char *function);
+void tomoyo_write_log(struct tomoyo_request_info *r, const char *fmt, ...)
+        __printf(2, 3);
+void tomoyo_write_log2(struct tomoyo_request_info *r, int len, const char *fmt,
+                       va_list args);
 
 /********** External variable definitions. **********/
 
-/* Lock for GC. */
-extern struct srcu_struct tomoyo_ss;
-
-/* The list for "struct tomoyo_domain_info". */
+extern bool tomoyo_policy_loaded;
+extern const char * const tomoyo_condition_keyword
+[TOMOYO_MAX_CONDITION_KEYWORD];
+extern const char * const tomoyo_dif[TOMOYO_MAX_DOMAIN_INFO_FLAGS];
+extern const char * const tomoyo_mac_keywords[TOMOYO_MAX_MAC_INDEX
+                                              + TOMOYO_MAX_MAC_CATEGORY_INDEX];
+extern const char * const tomoyo_mode[TOMOYO_CONFIG_MAX_MODE];
+extern const char * const tomoyo_path_keyword[TOMOYO_MAX_PATH_OPERATION];
+extern const u8 tomoyo_index2category[TOMOYO_MAX_MAC_INDEX];
+extern const u8 tomoyo_pn2mac[TOMOYO_MAX_PATH_NUMBER_OPERATION];
+extern const u8 tomoyo_pnnn2mac[TOMOYO_MAX_MKDEV_OPERATION];
+extern const u8 tomoyo_pp2mac[TOMOYO_MAX_PATH2_OPERATION];
+extern struct list_head tomoyo_condition_list;
 extern struct list_head tomoyo_domain_list;
-
-extern struct list_head tomoyo_policy_list[TOMOYO_MAX_POLICY];
-extern struct list_head tomoyo_group_list[TOMOYO_MAX_GROUP];
 extern struct list_head tomoyo_name_list[TOMOYO_MAX_HASH];
-
-/* Lock for protecting policy. */
+extern struct list_head tomoyo_namespace_list;
 extern struct mutex tomoyo_policy_lock;
-
-/* Has /sbin/init started? */
-extern bool tomoyo_policy_loaded;
-
-/* The kernel's domain. */
+extern struct srcu_struct tomoyo_ss;
 extern struct tomoyo_domain_info tomoyo_kernel_domain;
-
-extern const char *tomoyo_path_keyword[TOMOYO_MAX_PATH_OPERATION];
-extern const char *tomoyo_mkdev_keyword[TOMOYO_MAX_MKDEV_OPERATION];
-extern const char *tomoyo_path2_keyword[TOMOYO_MAX_PATH2_OPERATION];
-extern const char *tomoyo_path_number_keyword[TOMOYO_MAX_PATH_NUMBER_OPERATION];
-
-extern unsigned int tomoyo_quota_for_query;
-extern unsigned int tomoyo_query_memory_size;
+extern struct tomoyo_policy_namespace tomoyo_kernel_namespace;
+extern unsigned int tomoyo_memory_quota[TOMOYO_MAX_MEMORY_STAT];
+extern unsigned int tomoyo_memory_used[TOMOYO_MAX_MEMORY_STAT];
 
 /********** Inlined functions. **********/
 
+/**
+ * tomoyo_read_lock - Take lock for protecting policy.
+ *
+ * Returns index number for tomoyo_read_unlock().
+ */
 static inline int tomoyo_read_lock(void)
 {
         return srcu_read_lock(&tomoyo_ss);
 }
 
+/**
+ * tomoyo_read_unlock - Release lock for protecting policy.
+ *
+ * @idx: Index number returned by tomoyo_read_lock().
+ *
+ * Returns nothing.
+ */
 static inline void tomoyo_read_unlock(int idx)
 {
         srcu_read_unlock(&tomoyo_ss, idx);
 }
 
-/* strcmp() for "struct tomoyo_path_info" structure. */
-static inline bool tomoyo_pathcmp(const struct tomoyo_path_info *a,
-                                  const struct tomoyo_path_info *b)
+/**
+ * tomoyo_sys_getppid - Copy of getppid().
+ *
+ * Returns parent process's PID.
+ *
+ * Alpha does not have getppid() defined. To be able to build this module on
+ * Alpha, I have to copy getppid() from kernel/timer.c.
+ */
+static inline pid_t tomoyo_sys_getppid(void)
 {
-        return a->hash != b->hash || strcmp(a->name, b->name);
+        pid_t pid;
+        rcu_read_lock();
+        pid = task_tgid_vnr(current->real_parent);
+        rcu_read_unlock();
+        return pid;
 }
 
 /**
- * tomoyo_valid - Check whether the character is a valid char.
+ * tomoyo_sys_getpid - Copy of getpid().
  *
- * @c: The character to check.
+ * Returns current thread's PID.
  *
- * Returns true if @c is a valid character, false otherwise.
+ * Alpha does not have getpid() defined. To be able to build this module on
+ * Alpha, I have to copy getpid() from kernel/timer.c.
  */
-static inline bool tomoyo_valid(const unsigned char c)
+static inline pid_t tomoyo_sys_getpid(void)
 {
-        return c > ' ' && c < 127;
+        return task_tgid_vnr(current);
 }
 
 /**
- * tomoyo_invalid - Check whether the character is an invalid char.
+ * tomoyo_pathcmp - strcmp() for "struct tomoyo_path_info" structure.
  *
- * @c: The character to check.
+ * @a: Pointer to "struct tomoyo_path_info".
+ * @b: Pointer to "struct tomoyo_path_info".
  *
- * Returns true if @c is an invalid character, false otherwise.
+ * Returns true if @a == @b, false otherwise.
  */
-static inline bool tomoyo_invalid(const unsigned char c)
+static inline bool tomoyo_pathcmp(const struct tomoyo_path_info *a,
+                                  const struct tomoyo_path_info *b)
 {
-        return c && (c <= ' ' || c >= 127);
+        return a->hash != b->hash || strcmp(a->name, b->name);
 }
 
+/**
+ * tomoyo_put_name - Drop reference on "struct tomoyo_name".
+ *
+ * @name: Pointer to "struct tomoyo_path_info". Maybe NULL.
+ *
+ * Returns nothing.
+ */
 static inline void tomoyo_put_name(const struct tomoyo_path_info *name)
 {
         if (name) {
                 struct tomoyo_name *ptr =
                         container_of(name, typeof(*ptr), entry);
-                atomic_dec(&ptr->users);
+                atomic_dec(&ptr->head.users);
         }
 }
 
+/**
+ * tomoyo_put_condition - Drop reference on "struct tomoyo_condition".
+ *
+ * @cond: Pointer to "struct tomoyo_condition". Maybe NULL.
+ *
+ * Returns nothing.
+ */
+static inline void tomoyo_put_condition(struct tomoyo_condition *cond)
+{
+        if (cond)
+                atomic_dec(&cond->head.users);
+}
+
+/**
+ * tomoyo_put_group - Drop reference on "struct tomoyo_group".
+ *
+ * @group: Pointer to "struct tomoyo_group". Maybe NULL.
+ *
+ * Returns nothing.
+ */
 static inline void tomoyo_put_group(struct tomoyo_group *group)
 {
         if (group)
-                atomic_dec(&group->users);
+                atomic_dec(&group->head.users);
 }
 
+/**
+ * tomoyo_domain - Get "struct tomoyo_domain_info" for current thread.
+ *
+ * Returns pointer to "struct tomoyo_domain_info" for current thread.
+ */
 static inline struct tomoyo_domain_info *tomoyo_domain(void)
 {
         return current_cred()->security;
 }
 
+/**
+ * tomoyo_real_domain - Get "struct tomoyo_domain_info" for specified thread.
+ *
+ * @task: Pointer to "struct task_struct".
+ *
+ * Returns pointer to "struct tomoyo_security" for specified thread.
+ */
 static inline struct tomoyo_domain_info *tomoyo_real_domain(struct task_struct
                                                             *task)
 {
         return task_cred_xxx(task, security);
 }
 
-static inline bool tomoyo_same_acl_head(const struct tomoyo_acl_info *p1,
-                                           const struct tomoyo_acl_info *p2)
+/**
+ * tomoyo_same_name_union - Check for duplicated "struct tomoyo_name_union" entry.
+ *
+ * @a: Pointer to "struct tomoyo_name_union".
+ * @b: Pointer to "struct tomoyo_name_union".
+ *
+ * Returns true if @a == @b, false otherwise.
+ */
+static inline bool tomoyo_same_name_union
+(const struct tomoyo_name_union *a, const struct tomoyo_name_union *b)
 {
-        return p1->type == p2->type;
+        return a->filename == b->filename && a->group == b->group;
 }
 
-static inline bool tomoyo_same_name_union
-(const struct tomoyo_name_union *p1, const struct tomoyo_name_union *p2)
+/**
+ * tomoyo_same_number_union - Check for duplicated "struct tomoyo_number_union" entry.
+ *
+ * @a: Pointer to "struct tomoyo_number_union".
+ * @b: Pointer to "struct tomoyo_number_union".
+ *
+ * Returns true if @a == @b, false otherwise.
+ */
+static inline bool tomoyo_same_number_union
+(const struct tomoyo_number_union *a, const struct tomoyo_number_union *b)
 {
-        return p1->filename == p2->filename && p1->group == p2->group &&
-                p1->is_group == p2->is_group;
+        return a->values[0] == b->values[0] && a->values[1] == b->values[1] &&
+                a->group == b->group && a->value_type[0] == b->value_type[0] &&
+                a->value_type[1] == b->value_type[1];
 }
 
-static inline bool tomoyo_same_number_union
-(const struct tomoyo_number_union *p1, const struct tomoyo_number_union *p2)
+/**
+ * tomoyo_current_namespace - Get "struct tomoyo_policy_namespace" for current thread.
+ *
+ * Returns pointer to "struct tomoyo_policy_namespace" for current thread.
+ */
+static inline struct tomoyo_policy_namespace *tomoyo_current_namespace(void)
+{
+        return tomoyo_domain()->ns;
+}
+
+#if defined(CONFIG_SLOB)
+
+/**
+ * tomoyo_round2 - Round up to power of 2 for calculating memory usage.
+ *
+ * @size: Size to be rounded up.
+ *
+ * Returns @size.
+ *
+ * Since SLOB does not round up, this function simply returns @size.
+ */
+static inline int tomoyo_round2(size_t size)
+{
+        return size;
+}
+
+#else
+
+/**
+ * tomoyo_round2 - Round up to power of 2 for calculating memory usage.
+ *
+ * @size: Size to be rounded up.
+ *
+ * Returns rounded size.
+ *
+ * Strictly speaking, SLAB may be able to allocate (e.g.) 96 bytes instead of
+ * (e.g.) 128 bytes.
+ */
+static inline int tomoyo_round2(size_t size)
 {
-        return p1->values[0] == p2->values[0] && p1->values[1] == p2->values[1]
-                && p1->group == p2->group && p1->min_type == p2->min_type &&
-                p1->max_type == p2->max_type && p1->is_group == p2->is_group;
+#if PAGE_SIZE == 4096
+        size_t bsize = 32;
+#else
+        size_t bsize = 64;
+#endif
+        if (!size)
+                return 0;
+        while (size > bsize)
+                bsize <<= 1;
+        return bsize;
 }
 
+#endif
+
 /**
  * list_for_each_cookie - iterate over a list with cookie.
  * @pos:        the &struct list_head to use as a loop cursor.
diff --git a/security/tomoyo/condition.c b/security/tomoyo/condition.c
new file mode 100644
index 00000000000..8a05f71eaf6
--- /dev/null
+++ b/security/tomoyo/condition.c
@@ -0,0 +1,1035 @@
+/*
+ * security/tomoyo/condition.c
+ *
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
+ */
+
+#include "common.h"
+#include <linux/slab.h>
+
+/* List of "struct tomoyo_condition". */
+LIST_HEAD(tomoyo_condition_list);
+
+/**
+ * tomoyo_argv - Check argv[] in "struct linux_binbrm".
+ *
+ * @index:   Index number of @arg_ptr.
+ * @arg_ptr: Contents of argv[@index].
+ * @argc:    Length of @argv.
+ * @argv:    Pointer to "struct tomoyo_argv".
+ * @checked: Set to true if @argv[@index] was found.
+ *
+ * Returns true on success, false otherwise.
+ */
+static bool tomoyo_argv(const unsigned int index, const char *arg_ptr,
+                        const int argc, const struct tomoyo_argv *argv,
+                        u8 *checked)
+{
+        int i;
+        struct tomoyo_path_info arg;
+        arg.name = arg_ptr;
+        for (i = 0; i < argc; argv++, checked++, i++) {
+                bool result;
+                if (index != argv->index)
+                        continue;
+                *checked = 1;
+                tomoyo_fill_path_info(&arg);
+                result = tomoyo_path_matches_pattern(&arg, argv->value);
+                if (argv->is_not)
+                        result = !result;
+                if (!result)
+                        return false;
+        }
+        return true;
+}
+
+/**
+ * tomoyo_envp - Check envp[] in "struct linux_binbrm".
+ *
+ * @env_name:  The name of environment variable.
+ * @env_value: The value of environment variable.
+ * @envc:      Length of @envp.
+ * @envp:      Pointer to "struct tomoyo_envp".
+ * @checked:   Set to true if @envp[@env_name] was found.
+ *
+ * Returns true on success, false otherwise.
+ */
+static bool tomoyo_envp(const char *env_name, const char *env_value,
+                        const int envc, const struct tomoyo_envp *envp,
+                        u8 *checked)
+{
+        int i;
+        struct tomoyo_path_info name;
+        struct tomoyo_path_info value;
+        name.name = env_name;
+        tomoyo_fill_path_info(&name);
+        value.name = env_value;
+        tomoyo_fill_path_info(&value);
+        for (i = 0; i < envc; envp++, checked++, i++) {
+                bool result;
+                if (!tomoyo_path_matches_pattern(&name, envp->name))
+                        continue;
+                *checked = 1;
+                if (envp->value) {
+                        result = tomoyo_path_matches_pattern(&value,
+                                                             envp->value);
+                        if (envp->is_not)
+                                result = !result;
+                } else {
+                        result = true;
+                        if (!envp->is_not)
+                                result = !result;
+                }
+                if (!result)
+                        return false;
+        }
+        return true;
+}
+
+/**
+ * tomoyo_scan_bprm - Scan "struct linux_binprm".
+ *
+ * @ee:   Pointer to "struct tomoyo_execve".
+ * @argc: Length of @argc.
+ * @argv: Pointer to "struct tomoyo_argv".
+ * @envc: Length of @envp.
+ * @envp: Poiner to "struct tomoyo_envp".
+ *
+ * Returns true on success, false otherwise.
+ */
+static bool tomoyo_scan_bprm(struct tomoyo_execve *ee,
+                             const u16 argc, const struct tomoyo_argv *argv,
+                             const u16 envc, const struct tomoyo_envp *envp)
+{
+        struct linux_binprm *bprm = ee->bprm;
+        struct tomoyo_page_dump *dump = &ee->dump;
+        char *arg_ptr = ee->tmp;
+        int arg_len = 0;
+        unsigned long pos = bprm->p;
+        int offset = pos % PAGE_SIZE;
+        int argv_count = bprm->argc;
+        int envp_count = bprm->envc;
+        bool result = true;
+        u8 local_checked[32];
+        u8 *checked;
+        if (argc + envc <= sizeof(local_checked)) {
+                checked = local_checked;
+                memset(local_checked, 0, sizeof(local_checked));
+        } else {
+                checked = kzalloc(argc + envc, GFP_NOFS);
+                if (!checked)
+                        return false;
+        }
+        while (argv_count || envp_count) {
+                if (!tomoyo_dump_page(bprm, pos, dump)) {
+                        result = false;
+                        goto out;
+                }
+                pos += PAGE_SIZE - offset;
+                while (offset < PAGE_SIZE) {
+                        /* Read. */
+                        const char *kaddr = dump->data;
+                        const unsigned char c = kaddr[offset++];
+                        if (c && arg_len < TOMOYO_EXEC_TMPSIZE - 10) {
+                                if (c == '\\') {
+                                        arg_ptr[arg_len++] = '\\';
+                                        arg_ptr[arg_len++] = '\\';
+                                } else if (c > ' ' && c < 127) {
+                                        arg_ptr[arg_len++] = c;
+                                } else {
+                                        arg_ptr[arg_len++] = '\\';
+                                        arg_ptr[arg_len++] = (c >> 6) + '0';
+                                        arg_ptr[arg_len++] =
+                                                ((c >> 3) & 7) + '0';
+                                        arg_ptr[arg_len++] = (c & 7) + '0';
+                                }
+                        } else {
+                                arg_ptr[arg_len] = '\0';
+                        }
+                        if (c)
+                                continue;
+                        /* Check. */
+                        if (argv_count) {
+                                if (!tomoyo_argv(bprm->argc - argv_count,
+                                                 arg_ptr, argc, argv,
+                                                 checked)) {
+                                        result = false;
+                                        break;
+                                }
+                                argv_count--;
+                        } else if (envp_count) {
+                                char *cp = strchr(arg_ptr, '=');
+                                if (cp) {
+                                        *cp = '\0';
+                                        if (!tomoyo_envp(arg_ptr, cp + 1,
+                                                         envc, envp,
+                                                         checked + argc)) {
+                                                result = false;
+                                                break;
+                                        }
+                                }
+                                envp_count--;
+                        } else {
+                                break;
+                        }
+                        arg_len = 0;
+                }
+                offset = 0;
+                if (!result)
+                        break;
+        }
+out:
+        if (result) {
+                int i;
+                /* Check not-yet-checked entries. */
+                for (i = 0; i < argc; i++) {
+                        if (checked[i])
+                                continue;
+                        /*
+                         * Return true only if all unchecked indexes in
+                         * bprm->argv[] are not matched.
+                         */
+                        if (argv[i].is_not)
+                                continue;
+                        result = false;
+                        break;
+                }
+                for (i = 0; i < envc; envp++, i++) {
+                        if (checked[argc + i])
+                                continue;
+                        /*
+                         * Return true only if all unchecked environ variables
+                         * in bprm->envp[] are either undefined or not matched.
+                         */
+                        if ((!envp->value && !envp->is_not) ||
+                            (envp->value && envp->is_not))
+                                continue;
+                        result = false;
+                        break;
+                }
+        }
+        if (checked != local_checked)
+                kfree(checked);
+        return result;
+}
+
+/**
+ * tomoyo_scan_exec_realpath - Check "exec.realpath" parameter of "struct tomoyo_condition".
+ *
+ * @file:  Pointer to "struct file".
+ * @ptr:   Pointer to "struct tomoyo_name_union".
+ * @match: True if "exec.realpath=", false if "exec.realpath!=".
+ *
+ * Returns true on success, false otherwise.
+ */
+static bool tomoyo_scan_exec_realpath(struct file *file,
+                                      const struct tomoyo_name_union *ptr,
+                                      const bool match)
+{
+        bool result;
+        struct tomoyo_path_info exe;
+        if (!file)
+                return false;
+        exe.name = tomoyo_realpath_from_path(&file->f_path);
+        if (!exe.name)
+                return false;
+        tomoyo_fill_path_info(&exe);
+        result = tomoyo_compare_name_union(&exe, ptr);
+        kfree(exe.name);
+        return result == match;
+}
+
+/**
+ * tomoyo_get_dqword - tomoyo_get_name() for a quoted string.
+ *
+ * @start: String to save.
+ *
+ * Returns pointer to "struct tomoyo_path_info" on success, NULL otherwise.
+ */
+static const struct tomoyo_path_info *tomoyo_get_dqword(char *start)
+{
+        char *cp = start + strlen(start) - 1;
+        if (cp == start || *start++ != '"' || *cp != '"')
+                return NULL;
+        *cp = '\0';
+        if (*start && !tomoyo_correct_word(start))
+                return NULL;
+        return tomoyo_get_name(start);
+}
+
+/**
+ * tomoyo_parse_name_union_quoted - Parse a quoted word.
+ *
+ * @param: Pointer to "struct tomoyo_acl_param".
+ * @ptr:   Pointer to "struct tomoyo_name_union".
+ *
+ * Returns true on success, false otherwise.
+ */
+static bool tomoyo_parse_name_union_quoted(struct tomoyo_acl_param *param,
+                                           struct tomoyo_name_union *ptr)
+{
+        char *filename = param->data;
+        if (*filename == '@')
+                return tomoyo_parse_name_union(param, ptr);
+        ptr->filename = tomoyo_get_dqword(filename);
+        return ptr->filename != NULL;
+}
+
+/**
+ * tomoyo_parse_argv - Parse an argv[] condition part.
+ *
+ * @left:  Lefthand value.
+ * @right: Righthand value.
+ * @argv:  Pointer to "struct tomoyo_argv".
+ *
+ * Returns true on success, false otherwise.
+ */
+static bool tomoyo_parse_argv(char *left, char *right,
+                              struct tomoyo_argv *argv)
+{
+        if (tomoyo_parse_ulong(&argv->index, &left) !=
+            TOMOYO_VALUE_TYPE_DECIMAL || *left++ != ']' || *left)
+                return false;
+        argv->value = tomoyo_get_dqword(right);
+        return argv->value != NULL;
+}
+
+/**
+ * tomoyo_parse_envp - Parse an envp[] condition part.
+ *
+ * @left:  Lefthand value.
+ * @right: Righthand value.
+ * @envp:  Pointer to "struct tomoyo_envp".
+ *
+ * Returns true on success, false otherwise.
+ */
+static bool tomoyo_parse_envp(char *left, char *right,
+                              struct tomoyo_envp *envp)
+{
+        const struct tomoyo_path_info *name;
+        const struct tomoyo_path_info *value;
+        char *cp = left + strlen(left) - 1;
+        if (*cp-- != ']' || *cp != '"')
+                goto out;
+        *cp = '\0';
+        if (!tomoyo_correct_word(left))
+                goto out;
+        name = tomoyo_get_name(left);
+        if (!name)
+                goto out;
+        if (!strcmp(right, "NULL")) {
+                value = NULL;
+        } else {
+                value = tomoyo_get_dqword(right);
+                if (!value) {
+                        tomoyo_put_name(name);
+                        goto out;
+                }
+        }
+        envp->name = name;
+        envp->value = value;
+        return true;
+out:
+        return false;
+}
+
+/**
+ * tomoyo_same_condition - Check for duplicated "struct tomoyo_condition" entry.
+ *
+ * @a: Pointer to "struct tomoyo_condition".
+ * @b: Pointer to "struct tomoyo_condition".
+ *
+ * Returns true if @a == @b, false otherwise.
+ */
+static inline bool tomoyo_same_condition(const struct tomoyo_condition *a,
+                                         const struct tomoyo_condition *b)
+{
+        return a->size == b->size && a->condc == b->condc &&
+                a->numbers_count == b->numbers_count &&
+                a->names_count == b->names_count &&
+                a->argc == b->argc && a->envc == b->envc &&
+                !memcmp(a + 1, b + 1, a->size - sizeof(*a));
+}
+
+/**
+ * tomoyo_condition_type - Get condition type.
+ *
+ * @word: Keyword string.
+ *
+ * Returns one of values in "enum tomoyo_conditions_index" on success,
+ * TOMOYO_MAX_CONDITION_KEYWORD otherwise.
+ */
+static u8 tomoyo_condition_type(const char *word)
+{
+        u8 i;
+        for (i = 0; i < TOMOYO_MAX_CONDITION_KEYWORD; i++) {
+                if (!strcmp(word, tomoyo_condition_keyword[i]))
+                        break;
+        }
+        return i;
+}
+
+/* Define this to enable debug mode. */
+/* #define DEBUG_CONDITION */
+
+#ifdef DEBUG_CONDITION
+#define dprintk printk
+#else
+#define dprintk(...) do { } while (0)
+#endif
+
+/**
+ * tomoyo_commit_condition - Commit "struct tomoyo_condition".
+ *
+ * @entry: Pointer to "struct tomoyo_condition".
+ *
+ * Returns pointer to "struct tomoyo_condition" on success, NULL otherwise.
+ *
+ * This function merges duplicated entries. This function returns NULL if
+ * @entry is not duplicated but memory quota for policy has exceeded.
+ */
+static struct tomoyo_condition *tomoyo_commit_condition
+(struct tomoyo_condition *entry)
+{
+        struct tomoyo_condition *ptr;
+        bool found = false;
+        if (mutex_lock_interruptible(&tomoyo_policy_lock)) {
+                dprintk(KERN_WARNING "%u: %s failed\n", __LINE__, __func__);
+                ptr = NULL;
+                found = true;
+                goto out;
+        }
+        list_for_each_entry_rcu(ptr, &tomoyo_condition_list, head.list) {
+                if (!tomoyo_same_condition(ptr, entry))
+                        continue;
+                /* Same entry found. Share this entry. */
+                atomic_inc(&ptr->head.users);
+                found = true;
+                break;
+        }
+        if (!found) {
+                if (tomoyo_memory_ok(entry)) {
+                        atomic_set(&entry->head.users, 1);
+                        list_add_rcu(&entry->head.list,
+                                     &tomoyo_condition_list);
+                } else {
+                        found = true;
+                        ptr = NULL;
+                }
+        }
+        mutex_unlock(&tomoyo_policy_lock);
+out:
+        if (found) {
+                tomoyo_del_condition(&entry->head.list);
+                kfree(entry);
+                entry = ptr;
+        }
+        return entry;
+}
+
+/**
+ * tomoyo_get_condition - Parse condition part.
+ *
+ * @param: Pointer to "struct tomoyo_acl_param".
+ *
+ * Returns pointer to "struct tomoyo_condition" on success, NULL otherwise.
+ */
+struct tomoyo_condition *tomoyo_get_condition(struct tomoyo_acl_param *param)
+{
+        struct tomoyo_condition *entry = NULL;
+        struct tomoyo_condition_element *condp = NULL;
+        struct tomoyo_number_union *numbers_p = NULL;
+        struct tomoyo_name_union *names_p = NULL;
+        struct tomoyo_argv *argv = NULL;
+        struct tomoyo_envp *envp = NULL;
+        struct tomoyo_condition e = { };
+        char * const start_of_string = param->data;
+        char * const end_of_string = start_of_string + strlen(start_of_string);
+        char *pos;
+rerun:
+        pos = start_of_string;
+        while (1) {
+                u8 left = -1;
+                u8 right = -1;
+                char *left_word = pos;
+                char *cp;
+                char *right_word;
+                bool is_not;
+                if (!*left_word)
+                        break;
+                /*
+                 * Since left-hand condition does not allow use of "path_group"
+                 * or "number_group" and environment variable's names do not
+                 * accept '=', it is guaranteed that the original line consists
+                 * of one or more repetition of $left$operator$right blocks
+                 * where "$left is free from '=' and ' '" and "$operator is
+                 * either '=' or '!='" and "$right is free from ' '".
+                 * Therefore, we can reconstruct the original line at the end
+                 * of dry run even if we overwrite $operator with '\0'.
+                 */
+                cp = strchr(pos, ' ');
+                if (cp) {
+                        *cp = '\0'; /* Will restore later. */
+                        pos = cp + 1;
+                } else {
+                        pos = "";
+                }
+                right_word = strchr(left_word, '=');
+                if (!right_word || right_word == left_word)
+                        goto out;
+                is_not = *(right_word - 1) == '!';
+                if (is_not)
+                        *(right_word++ - 1) = '\0'; /* Will restore later. */
+                else if (*(right_word + 1) != '=')
+                        *right_word++ = '\0'; /* Will restore later. */
+                else
+                        goto out;
+                dprintk(KERN_WARNING "%u: <%s>%s=<%s>\n", __LINE__, left_word,
+                        is_not ? "!" : "", right_word);
+                if (!strncmp(left_word, "exec.argv[", 10)) {
+                        if (!argv) {
+                                e.argc++;
+                                e.condc++;
+                        } else {
+                                e.argc--;
+                                e.condc--;
+                                left = TOMOYO_ARGV_ENTRY;
+                                argv->is_not = is_not;
+                                if (!tomoyo_parse_argv(left_word + 10,
+                                                       right_word, argv++))
+                                        goto out;
+                        }
+                        goto store_value;
+                }
+                if (!strncmp(left_word, "exec.envp[\"", 11)) {
+                        if (!envp) {
+                                e.envc++;
+                                e.condc++;
+                        } else {
+                                e.envc--;
+                                e.condc--;
+                                left = TOMOYO_ENVP_ENTRY;
+                                envp->is_not = is_not;
+                                if (!tomoyo_parse_envp(left_word + 11,
+                                                       right_word, envp++))
+                                        goto out;
+                        }
+                        goto store_value;
+                }
+                left = tomoyo_condition_type(left_word);
+                dprintk(KERN_WARNING "%u: <%s> left=%u\n", __LINE__, left_word,
+                        left);
+                if (left == TOMOYO_MAX_CONDITION_KEYWORD) {
+                        if (!numbers_p) {
+                                e.numbers_count++;
+                        } else {
+                                e.numbers_count--;
+                                left = TOMOYO_NUMBER_UNION;
+                                param->data = left_word;
+                                if (*left_word == '@' ||
+                                    !tomoyo_parse_number_union(param,
+                                                               numbers_p++))
+                                        goto out;
+                        }
+                }
+                if (!condp)
+                        e.condc++;
+                else
+                        e.condc--;
+                if (left == TOMOYO_EXEC_REALPATH ||
+                    left == TOMOYO_SYMLINK_TARGET) {
+                        if (!names_p) {
+                                e.names_count++;
+                        } else {
+                                e.names_count--;
+                                right = TOMOYO_NAME_UNION;
+                                param->data = right_word;
+                                if (!tomoyo_parse_name_union_quoted(param,
+                                                                    names_p++))
+                                        goto out;
+                        }
+                        goto store_value;
+                }
+                right = tomoyo_condition_type(right_word);
+                if (right == TOMOYO_MAX_CONDITION_KEYWORD) {
+                        if (!numbers_p) {
+                                e.numbers_count++;
+                        } else {
+                                e.numbers_count--;
+                                right = TOMOYO_NUMBER_UNION;
+                                param->data = right_word;
+                                if (!tomoyo_parse_number_union(param,
+                                                               numbers_p++))
+                                        goto out;
+                        }
+                }
+store_value:
+                if (!condp) {
+                        dprintk(KERN_WARNING "%u: dry_run left=%u right=%u "
+                                "match=%u\n", __LINE__, left, right, !is_not);
+                        continue;
+                }
+                condp->left = left;
+                condp->right = right;
+                condp->equals = !is_not;
+                dprintk(KERN_WARNING "%u: left=%u right=%u match=%u\n",
+                        __LINE__, condp->left, condp->right,
+                        condp->equals);
+                condp++;
+        }
+        dprintk(KERN_INFO "%u: cond=%u numbers=%u names=%u ac=%u ec=%u\n",
+                __LINE__, e.condc, e.numbers_count, e.names_count, e.argc,
+                e.envc);
+        if (entry) {
+                BUG_ON(e.names_count | e.numbers_count | e.argc | e.envc |
+                       e.condc);
+                return tomoyo_commit_condition(entry);
+        }
+        e.size = sizeof(*entry)
+                + e.condc * sizeof(struct tomoyo_condition_element)
+                + e.numbers_count * sizeof(struct tomoyo_number_union)
+                + e.names_count * sizeof(struct tomoyo_name_union)
+                + e.argc * sizeof(struct tomoyo_argv)
+                + e.envc * sizeof(struct tomoyo_envp);
+        entry = kzalloc(e.size, GFP_NOFS);
+        if (!entry)
+                return NULL;
+        *entry = e;
+        condp = (struct tomoyo_condition_element *) (entry + 1);
+        numbers_p = (struct tomoyo_number_union *) (condp + e.condc);
+        names_p = (struct tomoyo_name_union *) (numbers_p + e.numbers_count);
+        argv = (struct tomoyo_argv *) (names_p + e.names_count);
+        envp = (struct tomoyo_envp *) (argv + e.argc);
+        {
+                bool flag = false;
+                for (pos = start_of_string; pos < end_of_string; pos++) {
+                        if (*pos)
+                                continue;
+                        if (flag) /* Restore " ". */
+                                *pos = ' ';
+                        else if (*(pos + 1) == '=') /* Restore "!=". */
+                                *pos = '!';
+                        else /* Restore "=". */
+                                *pos = '=';
+                        flag = !flag;
+                }
+        }
+        goto rerun;
+out:
+        dprintk(KERN_WARNING "%u: %s failed\n", __LINE__, __func__);
+        if (entry) {
+                tomoyo_del_condition(&entry->head.list);
+                kfree(entry);
+        }
+        return NULL;
+}
+
+/**
+ * tomoyo_get_attributes - Revalidate "struct inode".
+ *
+ * @obj: Pointer to "struct tomoyo_obj_info".
+ *
+ * Returns nothing.
+ */
+void tomoyo_get_attributes(struct tomoyo_obj_info *obj)
+{
+        u8 i;
+        struct dentry *dentry = NULL;
+
+        for (i = 0; i < TOMOYO_MAX_PATH_STAT; i++) {
+                struct inode *inode;
+                switch (i) {
+                case TOMOYO_PATH1:
+                        dentry = obj->path1.dentry;
+                        if (!dentry)
+                                continue;
+                        break;
+                case TOMOYO_PATH2:
+                        dentry = obj->path2.dentry;
+                        if (!dentry)
+                                continue;
+                        break;
+                default:
+                        if (!dentry)
+                                continue;
+                        dentry = dget_parent(dentry);
+                        break;
+                }
+                inode = dentry->d_inode;
+                if (inode) {
+                        struct tomoyo_mini_stat *stat = &obj->stat[i];
+                        stat->uid  = inode->i_uid;
+                        stat->gid  = inode->i_gid;
+                        stat->ino  = inode->i_ino;
+                        stat->mode = inode->i_mode;
+                        stat->dev  = inode->i_sb->s_dev;
+                        stat->rdev = inode->i_rdev;
+                        obj->stat_valid[i] = true;
+                }
+                if (i & 1) /* i == TOMOYO_PATH1_PARENT ||
+                              i == TOMOYO_PATH2_PARENT */
+                        dput(dentry);
+        }
+}
+
+/**
+ * tomoyo_condition - Check condition part.
+ *
+ * @r:    Pointer to "struct tomoyo_request_info".
+ * @cond: Pointer to "struct tomoyo_condition". Maybe NULL.
+ *
+ * Returns true on success, false otherwise.
+ *
+ * Caller holds tomoyo_read_lock().
+ */
+bool tomoyo_condition(struct tomoyo_request_info *r,
+                      const struct tomoyo_condition *cond)
+{
+        u32 i;
+        unsigned long min_v[2] = { 0, 0 };
+        unsigned long max_v[2] = { 0, 0 };
+        const struct tomoyo_condition_element *condp;
+        const struct tomoyo_number_union *numbers_p;
+        const struct tomoyo_name_union *names_p;
+        const struct tomoyo_argv *argv;
+        const struct tomoyo_envp *envp;
+        struct tomoyo_obj_info *obj;
+        u16 condc;
+        u16 argc;
+        u16 envc;
+        struct linux_binprm *bprm = NULL;
+        if (!cond)
+                return true;
+        condc = cond->condc;
+        argc = cond->argc;
+        envc = cond->envc;
+        obj = r->obj;
+        if (r->ee)
+                bprm = r->ee->bprm;
+        if (!bprm && (argc || envc))
+                return false;
+        condp = (struct tomoyo_condition_element *) (cond + 1);
+        numbers_p = (const struct tomoyo_number_union *) (condp + condc);
+        names_p = (const struct tomoyo_name_union *)
+                (numbers_p + cond->numbers_count);
+        argv = (const struct tomoyo_argv *) (names_p + cond->names_count);
+        envp = (const struct tomoyo_envp *) (argv + argc);
+        for (i = 0; i < condc; i++) {
+                const bool match = condp->equals;
+                const u8 left = condp->left;
+                const u8 right = condp->right;
+                bool is_bitop[2] = { false, false };
+                u8 j;
+                condp++;
+                /* Check argv[] and envp[] later. */
+                if (left == TOMOYO_ARGV_ENTRY || left == TOMOYO_ENVP_ENTRY)
+                        continue;
+                /* Check string expressions. */
+                if (right == TOMOYO_NAME_UNION) {
+                        const struct tomoyo_name_union *ptr = names_p++;
+                        switch (left) {
+                                struct tomoyo_path_info *symlink;
+                                struct tomoyo_execve *ee;
+                                struct file *file;
+                        case TOMOYO_SYMLINK_TARGET:
+                                symlink = obj ? obj->symlink_target : NULL;
+                                if (!symlink ||
+                                    !tomoyo_compare_name_union(symlink, ptr)
+                                    == match)
+                                        goto out;
+                                break;
+                        case TOMOYO_EXEC_REALPATH:
+                                ee = r->ee;
+                                file = ee ? ee->bprm->file : NULL;
+                                if (!tomoyo_scan_exec_realpath(file, ptr,
+                                                               match))
+                                        goto out;
+                                break;
+                        }
+                        continue;
+                }
+                /* Check numeric or bit-op expressions. */
+                for (j = 0; j < 2; j++) {
+                        const u8 index = j ? right : left;
+                        unsigned long value = 0;
+                        switch (index) {
+                        case TOMOYO_TASK_UID:
+                                value = current_uid();
+                                break;
+                        case TOMOYO_TASK_EUID:
+                                value = current_euid();
+                                break;
+                        case TOMOYO_TASK_SUID:
+                                value = current_suid();
+                                break;
+                        case TOMOYO_TASK_FSUID:
+                                value = current_fsuid();
+                                break;
+                        case TOMOYO_TASK_GID:
+                                value = current_gid();
+                                break;
+                        case TOMOYO_TASK_EGID:
+                                value = current_egid();
+                                break;
+                        case TOMOYO_TASK_SGID:
+                                value = current_sgid();
+                                break;
+                        case TOMOYO_TASK_FSGID:
+                                value = current_fsgid();
+                                break;
+                        case TOMOYO_TASK_PID:
+                                value = tomoyo_sys_getpid();
+                                break;
+                        case TOMOYO_TASK_PPID:
+                                value = tomoyo_sys_getppid();
+                                break;
+                        case TOMOYO_TYPE_IS_SOCKET:
+                                value = S_IFSOCK;
+                                break;
+                        case TOMOYO_TYPE_IS_SYMLINK:
+                                value = S_IFLNK;
+                                break;
+                        case TOMOYO_TYPE_IS_FILE:
+                                value = S_IFREG;
+                                break;
+                        case TOMOYO_TYPE_IS_BLOCK_DEV:
+                                value = S_IFBLK;
+                                break;
+                        case TOMOYO_TYPE_IS_DIRECTORY:
+                                value = S_IFDIR;
+                                break;
+                        case TOMOYO_TYPE_IS_CHAR_DEV:
+                                value = S_IFCHR;
+                                break;
+                        case TOMOYO_TYPE_IS_FIFO:
+                                value = S_IFIFO;
+                                break;
+                        case TOMOYO_MODE_SETUID:
+                                value = S_ISUID;
+                                break;
+                        case TOMOYO_MODE_SETGID:
+                                value = S_ISGID;
+                                break;
+                        case TOMOYO_MODE_STICKY:
+                                value = S_ISVTX;
+                                break;
+                        case TOMOYO_MODE_OWNER_READ:
+                                value = S_IRUSR;
+                                break;
+                        case TOMOYO_MODE_OWNER_WRITE:
+                                value = S_IWUSR;
+                                break;
+                        case TOMOYO_MODE_OWNER_EXECUTE:
+                                value = S_IXUSR;
+                                break;
+                        case TOMOYO_MODE_GROUP_READ:
+                                value = S_IRGRP;
+                                break;
+                        case TOMOYO_MODE_GROUP_WRITE:
+                                value = S_IWGRP;
+                                break;
+                        case TOMOYO_MODE_GROUP_EXECUTE:
+                                value = S_IXGRP;
+                                break;
+                        case TOMOYO_MODE_OTHERS_READ:
+                                value = S_IROTH;
+                                break;
+                        case TOMOYO_MODE_OTHERS_WRITE:
+                                value = S_IWOTH;
+                                break;
+                        case TOMOYO_MODE_OTHERS_EXECUTE:
+                                value = S_IXOTH;
+                                break;
+                        case TOMOYO_EXEC_ARGC:
+                                if (!bprm)
+                                        goto out;
+                                value = bprm->argc;
+                                break;
+                        case TOMOYO_EXEC_ENVC:
+                                if (!bprm)
+                                        goto out;
+                                value = bprm->envc;
+                                break;
+                        case TOMOYO_NUMBER_UNION:
+                                /* Fetch values later. */
+                                break;
+                        default:
+                                if (!obj)
+                                        goto out;
+                                if (!obj->validate_done) {
+                                        tomoyo_get_attributes(obj);
+                                        obj->validate_done = true;
+                                }
+                                {
+                                        u8 stat_index;
+                                        struct tomoyo_mini_stat *stat;
+                                        switch (index) {
+                                        case TOMOYO_PATH1_UID:
+                                        case TOMOYO_PATH1_GID:
+                                        case TOMOYO_PATH1_INO:
+                                        case TOMOYO_PATH1_MAJOR:
+                                        case TOMOYO_PATH1_MINOR:
+                                        case TOMOYO_PATH1_TYPE:
+                                        case TOMOYO_PATH1_DEV_MAJOR:
+                                        case TOMOYO_PATH1_DEV_MINOR:
+                                        case TOMOYO_PATH1_PERM:
+                                                stat_index = TOMOYO_PATH1;
+                                                break;
+                                        case TOMOYO_PATH2_UID:
+                                        case TOMOYO_PATH2_GID:
+                                        case TOMOYO_PATH2_INO:
+                                        case TOMOYO_PATH2_MAJOR:
+                                        case TOMOYO_PATH2_MINOR:
+                                        case TOMOYO_PATH2_TYPE:
+                                        case TOMOYO_PATH2_DEV_MAJOR:
+                                        case TOMOYO_PATH2_DEV_MINOR:
+                                        case TOMOYO_PATH2_PERM:
+                                                stat_index = TOMOYO_PATH2;
+                                                break;
+                                        case TOMOYO_PATH1_PARENT_UID:
+                                        case TOMOYO_PATH1_PARENT_GID:
+                                        case TOMOYO_PATH1_PARENT_INO:
+                                        case TOMOYO_PATH1_PARENT_PERM:
+                                                stat_index =
+                                                        TOMOYO_PATH1_PARENT;
+                                                break;
+                                        case TOMOYO_PATH2_PARENT_UID:
+                                        case TOMOYO_PATH2_PARENT_GID:
+                                        case TOMOYO_PATH2_PARENT_INO:
+                                        case TOMOYO_PATH2_PARENT_PERM:
+                                                stat_index =
+                                                        TOMOYO_PATH2_PARENT;
+                                                break;
+                                        default:
+                                                goto out;
+                                        }
+                                        if (!obj->stat_valid[stat_index])
+                                                goto out;
+                                        stat = &obj->stat[stat_index];
+                                        switch (index) {
+                                        case TOMOYO_PATH1_UID:
+                                        case TOMOYO_PATH2_UID:
+                                        case TOMOYO_PATH1_PARENT_UID:
+                                        case TOMOYO_PATH2_PARENT_UID:
+                                                value = stat->uid;
+                                                break;
+                                        case TOMOYO_PATH1_GID:
+                                        case TOMOYO_PATH2_GID:
+                                        case TOMOYO_PATH1_PARENT_GID:
+                                        case TOMOYO_PATH2_PARENT_GID:
+                                                value = stat->gid;
+                                                break;
+                                        case TOMOYO_PATH1_INO:
+                                        case TOMOYO_PATH2_INO:
+                                        case TOMOYO_PATH1_PARENT_INO:
+                                        case TOMOYO_PATH2_PARENT_INO:
+                                                value = stat->ino;
+                                                break;
+                                        case TOMOYO_PATH1_MAJOR:
+                                        case TOMOYO_PATH2_MAJOR:
+                                                value = MAJOR(stat->dev);
+                                                break;
+                                        case TOMOYO_PATH1_MINOR:
+                                        case TOMOYO_PATH2_MINOR:
+                                                value = MINOR(stat->dev);
+                                                break;
+                                        case TOMOYO_PATH1_TYPE:
+                                        case TOMOYO_PATH2_TYPE:
+                                                value = stat->mode & S_IFMT;
+                                                break;
+                                        case TOMOYO_PATH1_DEV_MAJOR:
+                                        case TOMOYO_PATH2_DEV_MAJOR:
+                                                value = MAJOR(stat->rdev);
+                                                break;
+                                        case TOMOYO_PATH1_DEV_MINOR:
+                                        case TOMOYO_PATH2_DEV_MINOR:
+                                                value = MINOR(stat->rdev);
+                                                break;
+                                        case TOMOYO_PATH1_PERM:
+                                        case TOMOYO_PATH2_PERM:
+                                        case TOMOYO_PATH1_PARENT_PERM:
+                                        case TOMOYO_PATH2_PARENT_PERM:
+                                                value = stat->mode & S_IALLUGO;
+                                                break;
+                                        }
+                                }
+                                break;
+                        }
+                        max_v[j] = value;
+                        min_v[j] = value;
+                        switch (index) {
+                        case TOMOYO_MODE_SETUID:
+                        case TOMOYO_MODE_SETGID:
+                        case TOMOYO_MODE_STICKY:
+                        case TOMOYO_MODE_OWNER_READ:
+                        case TOMOYO_MODE_OWNER_WRITE:
+                        case TOMOYO_MODE_OWNER_EXECUTE:
+                        case TOMOYO_MODE_GROUP_READ:
+                        case TOMOYO_MODE_GROUP_WRITE:
+                        case TOMOYO_MODE_GROUP_EXECUTE:
+                        case TOMOYO_MODE_OTHERS_READ:
+                        case TOMOYO_MODE_OTHERS_WRITE:
+                        case TOMOYO_MODE_OTHERS_EXECUTE:
+                                is_bitop[j] = true;
+                        }
+                }
+                if (left == TOMOYO_NUMBER_UNION) {
+                        /* Fetch values now. */
+                        const struct tomoyo_number_union *ptr = numbers_p++;
+                        min_v[0] = ptr->values[0];
+                        max_v[0] = ptr->values[1];
+                }
+                if (right == TOMOYO_NUMBER_UNION) {
+                        /* Fetch values now. */
+                        const struct tomoyo_number_union *ptr = numbers_p++;
+                        if (ptr->group) {
+                                if (tomoyo_number_matches_group(min_v[0],
+                                                                max_v[0],
+                                                                ptr->group)
+                                    == match)
+                                        continue;
+                        } else {
+                                if ((min_v[0] <= ptr->values[1] &&
+                                     max_v[0] >= ptr->values[0]) == match)
+                                        continue;
+                        }
+                        goto out;
+                }
+                /*
+                 * Bit operation is valid only when counterpart value
+                 * represents permission.
+                 */
+                if (is_bitop[0] && is_bitop[1]) {
+                        goto out;
+                } else if (is_bitop[0]) {
+                        switch (right) {
+                        case TOMOYO_PATH1_PERM:
+                        case TOMOYO_PATH1_PARENT_PERM:
+                        case TOMOYO_PATH2_PERM:
+                        case TOMOYO_PATH2_PARENT_PERM:
+                                if (!(max_v[0] & max_v[1]) == !match)
+                                        continue;
+                        }
+                        goto out;
+                } else if (is_bitop[1]) {
+                        switch (left) {
+                        case TOMOYO_PATH1_PERM:
+                        case TOMOYO_PATH1_PARENT_PERM:
+                        case TOMOYO_PATH2_PERM:
+                        case TOMOYO_PATH2_PARENT_PERM:
+                                if (!(max_v[0] & max_v[1]) == !match)
+                                        continue;
+                        }
+                        goto out;
+                }
+                /* Normal value range comparison. */
+                if ((min_v[0] <= max_v[1] && max_v[0] >= min_v[1]) == match)
+                        continue;
+out:
+                return false;
+        }
+        /* Check argv[] and envp[] now. */
+        if (r->ee && (argc || envc))
+                return tomoyo_scan_bprm(r->ee, argc, argv, envc, envp);
+        return true;
+}
diff --git a/security/tomoyo/domain.c b/security/tomoyo/domain.c
index 35388408e47..cd0f92d88bb 100644
--- a/security/tomoyo/domain.c
+++ b/security/tomoyo/domain.c
@@ -1,9 +1,7 @@
 /*
  * security/tomoyo/domain.c
  *
- * Domain transition functions for TOMOYO.
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
  */
 
 #include "common.h"
@@ -20,8 +18,7 @@ struct tomoyo_domain_info tomoyo_kernel_domain;
  *
  * @new_entry:       Pointer to "struct tomoyo_acl_info".
  * @size:            Size of @new_entry in bytes.
- * @is_delete:       True if it is a delete request.
- * @list:            Pointer to "struct list_head".
+ * @param:           Pointer to "struct tomoyo_acl_param".
  * @check_duplicate: Callback function to find duplicated entry.
  *
  * Returns 0 on success, negative value otherwise.
@@ -29,25 +26,26 @@ struct tomoyo_domain_info tomoyo_kernel_domain;
  * Caller holds tomoyo_read_lock().
  */
 int tomoyo_update_policy(struct tomoyo_acl_head *new_entry, const int size,
-                         bool is_delete, struct list_head *list,
+                         struct tomoyo_acl_param *param,
                          bool (*check_duplicate) (const struct tomoyo_acl_head
                                                   *,
                                                   const struct tomoyo_acl_head
                                                   *))
 {
-        int error = is_delete ? -ENOENT : -ENOMEM;
+        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 = is_delete;
+                entry->is_deleted = param->is_delete;
                 error = 0;
                 break;
         }
-        if (error && !is_delete) {
+        if (error && !param->is_delete) {
                 entry = tomoyo_commit_ok(new_entry, size);
                 if (entry) {
                         list_add_tail_rcu(&entry->list, list);
@@ -59,12 +57,25 @@ int tomoyo_update_policy(struct tomoyo_acl_head *new_entry, const int size,
 }
 
 /**
+ * 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.
- * @is_delete:       True if it is a delete request.
- * @domain:          Pointer to "struct tomoyo_domain_info".
+ * @param:           Pointer to "struct tomoyo_acl_param".
  * @check_duplicate: Callback function to find duplicated entry.
  * @merge_duplicate: Callback function to merge duplicated entry.
  *
@@ -73,7 +84,7 @@ int tomoyo_update_policy(struct tomoyo_acl_head *new_entry, const int size,
  * Caller holds tomoyo_read_lock().
  */
 int tomoyo_update_domain(struct tomoyo_acl_info *new_entry, const int size,
-                         bool is_delete, struct tomoyo_domain_info *domain,
+                         struct tomoyo_acl_param *param,
                          bool (*check_duplicate) (const struct tomoyo_acl_info
                                                   *,
                                                   const struct tomoyo_acl_info
@@ -82,13 +93,21 @@ int tomoyo_update_domain(struct tomoyo_acl_info *new_entry, const int size,
                                                   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))
-                return error;
-        list_for_each_entry_rcu(entry, &domain->acl_info_list, list) {
-                if (!check_duplicate(entry, new_entry))
+                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,
@@ -101,28 +120,50 @@ int tomoyo_update_domain(struct tomoyo_acl_info *new_entry, const int size,
         if (error && !is_delete) {
                 entry = tomoyo_commit_ok(new_entry, size);
                 if (entry) {
-                        list_add_tail_rcu(&entry->list, &domain->acl_info_list);
+                        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;
 
-        list_for_each_entry_rcu(ptr, &domain->acl_info_list, 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)) {
-                        r->granted = true;
-                        return;
-                }
+                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;
 }
@@ -130,24 +171,29 @@ void tomoyo_check_acl(struct tomoyo_request_info *r,
 /* The list for "struct tomoyo_domain_info". */
 LIST_HEAD(tomoyo_domain_list);
 
-struct list_head tomoyo_policy_list[TOMOYO_MAX_POLICY];
-struct list_head tomoyo_group_list[TOMOYO_MAX_GROUP];
-
 /**
  * tomoyo_last_word - Get last component of a domainname.
  *
- * @domainname: Domainname to check.
+ * @name: Domainname to check.
  *
  * Returns the last word of @domainname.
  */
 static const char *tomoyo_last_word(const char *name)
 {
-        const char *cp = strrchr(name, ' ');
-        if (cp)
-                return cp + 1;
-        return name;
+        const char *cp = strrchr(name, ' ');
+        if (cp)
+                return cp + 1;
+        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)
 {
@@ -163,30 +209,36 @@ static bool tomoyo_same_transition_control(const struct tomoyo_acl_head *a,
 }
 
 /**
- * tomoyo_update_transition_control_entry - Update "struct tomoyo_transition_control" list.
+ * tomoyo_write_transition_control - Write "struct tomoyo_transition_control" list.
  *
- * @domainname: The name of domain. Maybe NULL.
- * @program:    The name of program. Maybe NULL.
- * @type:       Type of transition.
- * @is_delete:  True if it is a delete request.
+ * @param: Pointer to "struct tomoyo_acl_param".
+ * @type:  Type of this entry.
  *
  * Returns 0 on success, negative value otherwise.
  */
-static int tomoyo_update_transition_control_entry(const char *domainname,
-                                                  const char *program,
-                                                  const u8 type,
-                                                  const bool is_delete)
+int tomoyo_write_transition_control(struct tomoyo_acl_param *param,
+                                    const u8 type)
 {
         struct tomoyo_transition_control e = { .type = type };
-        int error = is_delete ? -ENOENT : -ENOMEM;
-        if (program) {
+        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) {
+        if (domainname && strcmp(domainname, "any")) {
                 if (!tomoyo_correct_domain(domainname)) {
                         if (!tomoyo_correct_path(domainname))
                                 goto out;
@@ -196,126 +248,136 @@ static int tomoyo_update_transition_control_entry(const char *domainname,
                 if (!e.domainname)
                         goto out;
         }
-        error = tomoyo_update_policy(&e.head, sizeof(e), is_delete,
-                                     &tomoyo_policy_list
-                                     [TOMOYO_ID_TRANSITION_CONTROL],
+        param->list = &param->ns->policy_list[TOMOYO_ID_TRANSITION_CONTROL];
+        error = tomoyo_update_policy(&e.head, sizeof(e), param,
                                      tomoyo_same_transition_control);
- out:
+out:
         tomoyo_put_name(e.domainname);
         tomoyo_put_name(e.program);
         return error;
 }
 
 /**
- * tomoyo_write_transition_control - Write "struct tomoyo_transition_control" list.
+ * tomoyo_scan_transition - Try to find specific domain transition type.
  *
- * @data:      String to parse.
- * @is_delete: True if it is a delete request.
- * @type:      Type of this entry.
+ * @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 0 on success, negative value otherwise.
+ * Returns true if found one, false otherwise.
+ *
+ * Caller holds tomoyo_read_lock().
  */
-int tomoyo_write_transition_control(char *data, const bool is_delete,
-                                    const u8 type)
+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)
 {
-        char *domainname = strstr(data, " from ");
-        if (domainname) {
-                *domainname = '\0';
-                domainname += 6;
-        } else if (type == TOMOYO_TRANSITION_CONTROL_NO_KEEP ||
-                   type == TOMOYO_TRANSITION_CONTROL_KEEP) {
-                domainname = data;
-                data = NULL;
+        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 tomoyo_update_transition_control_entry(domainname, data, type,
-                                                      is_delete);
+        return false;
 }
 
 /**
  * tomoyo_transition_type - Get domain transition type.
  *
- * @domainname: The name of domain.
- * @program:    The name of program.
+ * @ns:         Pointer to "struct tomoyo_policy_namespace".
+ * @domainname: The name of current domain.
+ * @program:    The name of requested program.
  *
- * Returns TOMOYO_TRANSITION_CONTROL_INITIALIZE if executing @program
- * reinitializes domain transition, TOMOYO_TRANSITION_CONTROL_KEEP if executing
- * @program suppresses domain transition, others otherwise.
+ * 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 u8 tomoyo_transition_type(const struct tomoyo_path_info *domainname,
-                                 const struct tomoyo_path_info *program)
+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 struct tomoyo_transition_control *ptr;
         const char *last_name = tomoyo_last_word(domainname->name);
-        u8 type;
-        for (type = 0; type < TOMOYO_MAX_TRANSITION_TYPE; type++) {
- next:
-                list_for_each_entry_rcu(ptr, &tomoyo_policy_list
-                                        [TOMOYO_ID_TRANSITION_CONTROL],
-                                        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;
-                        if (type == TOMOYO_TRANSITION_CONTROL_NO_INITIALIZE) {
-                                /*
-                                 * Do not check for initialize_domain if
-                                 * no_initialize_domain matched.
-                                 */
-                                type = TOMOYO_TRANSITION_CONTROL_NO_KEEP;
-                                goto next;
-                        }
-                        goto done;
+        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++;
         }
- done:
         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);
+        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_update_aggregator_entry - Update "struct tomoyo_aggregator" list.
+ * tomoyo_write_aggregator - Write "struct tomoyo_aggregator" list.
  *
- * @original_name:   The original program's name.
- * @aggregated_name: The program name to use.
- * @is_delete:       True if it is a delete request.
+ * @param: Pointer to "struct tomoyo_acl_param".
  *
  * Returns 0 on success, negative value otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
-static int tomoyo_update_aggregator_entry(const char *original_name,
-                                          const char *aggregated_name,
-                                          const bool is_delete)
+int tomoyo_write_aggregator(struct tomoyo_acl_param *param)
 {
         struct tomoyo_aggregator e = { };
-        int error = is_delete ? -ENOENT : -ENOMEM;
-
-        if (!tomoyo_correct_path(original_name) ||
+        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);
@@ -323,83 +385,181 @@ static int tomoyo_update_aggregator_entry(const char *original_name,
         if (!e.original_name || !e.aggregated_name ||
             e.aggregated_name->is_patterned) /* No patterns allowed. */
                 goto out;
-        error = tomoyo_update_policy(&e.head, sizeof(e), is_delete,
-                                     &tomoyo_policy_list[TOMOYO_ID_AGGREGATOR],
+        param->list = &param->ns->policy_list[TOMOYO_ID_AGGREGATOR];
+        error = tomoyo_update_policy(&e.head, sizeof(e), param,
                                      tomoyo_same_aggregator);
- out:
+out:
         tomoyo_put_name(e.original_name);
         tomoyo_put_name(e.aggregated_name);
         return error;
 }
 
 /**
- * tomoyo_write_aggregator - Write "struct tomoyo_aggregator" list.
+ * tomoyo_find_namespace - Find specified namespace.
  *
- * @data:      String to parse.
- * @is_delete: True if it is a delete request.
+ * @name: Name of namespace to find.
+ * @len:  Length of @name.
  *
- * Returns 0 on success, negative value otherwise.
+ * Returns pointer to "struct tomoyo_policy_namespace" if found,
+ * NULL otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
-int tomoyo_write_aggregator(char *data, const bool is_delete)
+static struct tomoyo_policy_namespace *tomoyo_find_namespace
+(const char *name, const unsigned int len)
 {
-        char *cp = strchr(data, ' ');
+        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;
+}
 
-        if (!cp)
-                return -EINVAL;
-        *cp++ = '\0';
-        return tomoyo_update_aggregator_entry(data, cp, is_delete);
+/**
+ * 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_assign_domain - Create a domain.
+ * 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.
- * @profile:    Profile number to assign if the domain was newly created.
+ * @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 u8 profile)
+                                                const bool transit)
 {
-        struct tomoyo_domain_info *entry;
-        struct tomoyo_domain_info *domain = NULL;
-        const struct tomoyo_path_info *saved_domainname;
-        bool found = false;
-
-        if (!tomoyo_correct_domain(domainname))
+        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;
-        saved_domainname = tomoyo_get_name(domainname);
-        if (!saved_domainname)
+        /*
+         * "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;
-        entry = kzalloc(sizeof(*entry), GFP_NOFS);
         if (mutex_lock_interruptible(&tomoyo_policy_lock))
                 goto out;
-        list_for_each_entry_rcu(domain, &tomoyo_domain_list, list) {
-                if (domain->is_deleted ||
-                    tomoyo_pathcmp(saved_domainname, domain->domainname))
-                        continue;
-                found = true;
-                break;
-        }
-        if (!found && tomoyo_memory_ok(entry)) {
-                INIT_LIST_HEAD(&entry->acl_info_list);
-                entry->domainname = saved_domainname;
-                saved_domainname = NULL;
-                entry->profile = profile;
-                list_add_tail_rcu(&entry->list, &tomoyo_domain_list);
-                domain = entry;
-                entry = NULL;
-                found = true;
+        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(saved_domainname);
-        kfree(entry);
-        return found ? domain : NULL;
+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;
 }
 
 /**
@@ -413,22 +573,27 @@ struct tomoyo_domain_info *tomoyo_assign_domain(const char *domainname,
  */
 int tomoyo_find_next_domain(struct linux_binprm *bprm)
 {
-        struct tomoyo_request_info r;
-        char *tmp = kzalloc(TOMOYO_EXEC_TMPSIZE, GFP_NOFS);
         struct tomoyo_domain_info *old_domain = tomoyo_domain();
         struct tomoyo_domain_info *domain = NULL;
         const char *original_name = bprm->filename;
-        u8 mode;
-        bool is_enforce;
         int retval = -ENOMEM;
         bool need_kfree = false;
+        bool reject_on_transition_failure = false;
         struct tomoyo_path_info rn = { }; /* real name */
-
-        mode = tomoyo_init_request_info(&r, NULL, TOMOYO_MAC_FILE_EXECUTE);
-        is_enforce = (mode == TOMOYO_CONFIG_ENFORCING);
-        if (!tmp)
-                goto out;
-
+        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);
@@ -445,8 +610,10 @@ int tomoyo_find_next_domain(struct linux_binprm *bprm)
         /* Check 'aggregator' directive. */
         {
                 struct tomoyo_aggregator *ptr;
-                list_for_each_entry_rcu(ptr, &tomoyo_policy_list
-                                        [TOMOYO_ID_AGGREGATOR], head.list) {
+                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))
@@ -460,7 +627,7 @@ int tomoyo_find_next_domain(struct linux_binprm *bprm)
         }
 
         /* Check execute permission. */
-        retval = tomoyo_path_permission(&r, TOMOYO_TYPE_EXECUTE, &rn);
+        retval = tomoyo_path_permission(&ee->r, TOMOYO_TYPE_EXECUTE, &rn);
         if (retval == TOMOYO_RETRY_REQUEST)
                 goto retry;
         if (retval < 0)
@@ -471,20 +638,30 @@ int tomoyo_find_next_domain(struct linux_binprm *bprm)
          * wildcard) rather than the pathname passed to execve()
          * (which never contains wildcard).
          */
-        if (r.param.path.matched_path) {
+        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 = *r.param.path.matched_path;
+                rn = *ee->r.param.path.matched_path;
         }
 
         /* Calculate domain to transit to. */
-        switch (tomoyo_transition_type(old_domain->domainname, &rn)) {
+        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 tomoyo_kernel_domain domain. */
-                snprintf(tmp, TOMOYO_EXEC_TMPSIZE - 1, TOMOYO_ROOT_NAME " "
-                         "%s", rn.name);
+                /* 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. */
@@ -502,33 +679,32 @@ int tomoyo_find_next_domain(struct linux_binprm *bprm)
                         domain = old_domain;
                 } else {
                         /* Normal domain transition. */
-                        snprintf(tmp, TOMOYO_EXEC_TMPSIZE - 1, "%s %s",
+                        snprintf(ee->tmp, TOMOYO_EXEC_TMPSIZE - 1, "%s %s",
                                  old_domain->domainname->name, rn.name);
                 }
                 break;
         }
-        if (domain || strlen(tmp) >= TOMOYO_EXEC_TMPSIZE - 10)
-                goto done;
-        domain = tomoyo_find_domain(tmp);
+        if (!domain)
+                domain = tomoyo_assign_domain(ee->tmp, true);
         if (domain)
-                goto done;
-        if (is_enforce) {
-                int error = tomoyo_supervisor(&r, "# wants to create domain\n"
-                                              "%s\n", tmp);
-                if (error == TOMOYO_RETRY_REQUEST)
-                        goto retry;
-                if (error < 0)
-                        goto done;
+                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);
+                }
         }
-        domain = tomoyo_assign_domain(tmp, old_domain->profile);
- done:
-        if (domain)
-                goto out;
-        printk(KERN_WARNING "TOMOYO-ERROR: Domain '%s' not defined.\n", tmp);
-        if (is_enforce)
-                retval = -EPERM;
-        else
-                old_domain->transition_failed = true;
  out:
         if (!domain)
                 domain = old_domain;
@@ -537,6 +713,54 @@ int tomoyo_find_next_domain(struct linux_binprm *bprm)
         bprm->cred->security = domain;
         if (need_kfree)
                 kfree(rn.name);
-        kfree(tmp);
+        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;
+}
diff --git a/security/tomoyo/file.c b/security/tomoyo/file.c
index d64e8ecb6fb..743c35f5084 100644
--- a/security/tomoyo/file.c
+++ b/security/tomoyo/file.c
@@ -1,80 +1,51 @@
 /*
  * security/tomoyo/file.c
  *
- * Pathname restriction functions.
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
  */
 
 #include "common.h"
 #include <linux/slab.h>
 
-/* Keyword array for operations with one pathname. */
-const char *tomoyo_path_keyword[TOMOYO_MAX_PATH_OPERATION] = {
-        [TOMOYO_TYPE_READ_WRITE] = "read/write",
-        [TOMOYO_TYPE_EXECUTE]    = "execute",
-        [TOMOYO_TYPE_READ]       = "read",
-        [TOMOYO_TYPE_WRITE]      = "write",
-        [TOMOYO_TYPE_UNLINK]     = "unlink",
-        [TOMOYO_TYPE_RMDIR]      = "rmdir",
-        [TOMOYO_TYPE_TRUNCATE]   = "truncate",
-        [TOMOYO_TYPE_SYMLINK]    = "symlink",
-        [TOMOYO_TYPE_REWRITE]    = "rewrite",
-        [TOMOYO_TYPE_CHROOT]     = "chroot",
-        [TOMOYO_TYPE_UMOUNT]     = "unmount",
-};
-
-/* Keyword array for operations with one pathname and three numbers. */
-const char *tomoyo_mkdev_keyword[TOMOYO_MAX_MKDEV_OPERATION] = {
-        [TOMOYO_TYPE_MKBLOCK]    = "mkblock",
-        [TOMOYO_TYPE_MKCHAR]     = "mkchar",
-};
-
-/* Keyword array for operations with two pathnames. */
-const char *tomoyo_path2_keyword[TOMOYO_MAX_PATH2_OPERATION] = {
-        [TOMOYO_TYPE_LINK]       = "link",
-        [TOMOYO_TYPE_RENAME]     = "rename",
-        [TOMOYO_TYPE_PIVOT_ROOT] = "pivot_root",
-};
-
-/* Keyword array for operations with one pathname and one number. */
-const char *tomoyo_path_number_keyword[TOMOYO_MAX_PATH_NUMBER_OPERATION] = {
-        [TOMOYO_TYPE_CREATE]     = "create",
-        [TOMOYO_TYPE_MKDIR]      = "mkdir",
-        [TOMOYO_TYPE_MKFIFO]     = "mkfifo",
-        [TOMOYO_TYPE_MKSOCK]     = "mksock",
-        [TOMOYO_TYPE_IOCTL]      = "ioctl",
-        [TOMOYO_TYPE_CHMOD]      = "chmod",
-        [TOMOYO_TYPE_CHOWN]      = "chown",
-        [TOMOYO_TYPE_CHGRP]      = "chgrp",
-};
-
+/*
+ * Mapping table from "enum tomoyo_path_acl_index" to "enum tomoyo_mac_index".
+ */
 static const u8 tomoyo_p2mac[TOMOYO_MAX_PATH_OPERATION] = {
-        [TOMOYO_TYPE_READ_WRITE] = TOMOYO_MAC_FILE_OPEN,
         [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_REWRITE]    = TOMOYO_MAC_FILE_REWRITE,
         [TOMOYO_TYPE_CHROOT]     = TOMOYO_MAC_FILE_CHROOT,
         [TOMOYO_TYPE_UMOUNT]     = TOMOYO_MAC_FILE_UMOUNT,
 };
 
-static const u8 tomoyo_pnnn2mac[TOMOYO_MAX_MKDEV_OPERATION] = {
+/*
+ * 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,
 };
 
-static const u8 tomoyo_pp2mac[TOMOYO_MAX_PATH2_OPERATION] = {
+/*
+ * 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,
 };
 
-static const u8 tomoyo_pn2mac[TOMOYO_MAX_PATH_NUMBER_OPERATION] = {
+/*
+ * 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,
@@ -85,41 +56,76 @@ static const u8 tomoyo_pn2mac[TOMOYO_MAX_PATH_NUMBER_OPERATION] = {
         [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)
 {
-        if (!ptr)
-                return;
-        if (ptr->is_group)
-                tomoyo_put_group(ptr->group);
-        else
-                tomoyo_put_name(ptr->filename);
+        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->is_group)
+        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)
 {
-        if (ptr && ptr->is_group)
-                tomoyo_put_group(ptr->group);
+        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->is_group)
+        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)
@@ -132,24 +138,6 @@ static void tomoyo_add_slash(struct tomoyo_path_info *buf)
 }
 
 /**
- * tomoyo_strendswith - Check whether the token ends with the given token.
- *
- * @name: The token to check.
- * @tail: The token to find.
- *
- * Returns true if @name ends with @tail, false otherwise.
- */
-static bool tomoyo_strendswith(const char *name, const char *tail)
-{
-        int len;
-
-        if (!name || !tail)
-                return false;
-        len = strlen(name) - strlen(tail);
-        return len >= 0 && !strcmp(name + len, tail);
-}
-
-/**
  * tomoyo_get_realpath - Get realpath.
  *
  * @buf:  Pointer to "struct tomoyo_path_info".
@@ -164,7 +152,7 @@ static bool tomoyo_get_realpath(struct tomoyo_path_info *buf, struct path *path)
                 tomoyo_fill_path_info(buf);
                 return true;
         }
-        return false;
+        return false;
 }
 
 /**
@@ -176,13 +164,9 @@ static bool tomoyo_get_realpath(struct tomoyo_path_info *buf, struct path *path)
  */
 static int tomoyo_audit_path_log(struct tomoyo_request_info *r)
 {
-        const char *operation = tomoyo_path_keyword[r->param.path.operation];
-        const struct tomoyo_path_info *filename = r->param.path.filename;
-        if (r->granted)
-                return 0;
-        tomoyo_warn_log(r, "%s %s", operation, filename->name);
-        return tomoyo_supervisor(r, "allow_%s %s\n", operation,
-                                 tomoyo_pattern(filename));
+        return tomoyo_supervisor(r, "file %s %s\n", tomoyo_path_keyword
+                                 [r->param.path.operation],
+                                 r->param.path.filename->name);
 }
 
 /**
@@ -194,16 +178,10 @@ static int tomoyo_audit_path_log(struct tomoyo_request_info *r)
  */
 static int tomoyo_audit_path2_log(struct tomoyo_request_info *r)
 {
-        const char *operation = tomoyo_path2_keyword[r->param.path2.operation];
-        const struct tomoyo_path_info *filename1 = r->param.path2.filename1;
-        const struct tomoyo_path_info *filename2 = r->param.path2.filename2;
-        if (r->granted)
-                return 0;
-        tomoyo_warn_log(r, "%s %s %s", operation, filename1->name,
-                        filename2->name);
-        return tomoyo_supervisor(r, "allow_%s %s %s\n", operation,
-                                 tomoyo_pattern(filename1),
-                                 tomoyo_pattern(filename2));
+        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);
 }
 
 /**
@@ -215,24 +193,18 @@ static int tomoyo_audit_path2_log(struct tomoyo_request_info *r)
  */
 static int tomoyo_audit_mkdev_log(struct tomoyo_request_info *r)
 {
-        const char *operation = tomoyo_mkdev_keyword[r->param.mkdev.operation];
-        const struct tomoyo_path_info *filename = r->param.mkdev.filename;
-        const unsigned int major = r->param.mkdev.major;
-        const unsigned int minor = r->param.mkdev.minor;
-        const unsigned int mode = r->param.mkdev.mode;
-        if (r->granted)
-                return 0;
-        tomoyo_warn_log(r, "%s %s 0%o %u %u", operation, filename->name, mode,
-                        major, minor);
-        return tomoyo_supervisor(r, "allow_%s %s 0%o %u %u\n", operation,
-                                 tomoyo_pattern(filename), mode, major, minor);
+        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".
- * @error: Error code.
+ * @r: Pointer to "struct tomoyo_request_info".
  *
  * Returns 0 on success, negative value otherwise.
  */
@@ -240,11 +212,7 @@ static int tomoyo_audit_path_number_log(struct tomoyo_request_info *r)
 {
         const u8 type = r->param.path_number.operation;
         u8 radix;
-        const struct tomoyo_path_info *filename = r->param.path_number.filename;
-        const char *operation = tomoyo_path_number_keyword[type];
         char buffer[64];
-        if (r->granted)
-                return 0;
         switch (type) {
         case TOMOYO_TYPE_CREATE:
         case TOMOYO_TYPE_MKDIR:
@@ -262,251 +230,23 @@ static int tomoyo_audit_path_number_log(struct tomoyo_request_info *r)
         }
         tomoyo_print_ulong(buffer, sizeof(buffer), r->param.path_number.number,
                            radix);
-        tomoyo_warn_log(r, "%s %s %s", operation, filename->name, buffer);
-        return tomoyo_supervisor(r, "allow_%s %s %s\n", operation,
-                                 tomoyo_pattern(filename), buffer);
-}
-
-static bool tomoyo_same_globally_readable(const struct tomoyo_acl_head *a,
-                                          const struct tomoyo_acl_head *b)
-{
-        return container_of(a, struct tomoyo_readable_file,
-                            head)->filename ==
-                container_of(b, struct tomoyo_readable_file,
-                             head)->filename;
-}
-
-/**
- * tomoyo_update_globally_readable_entry - Update "struct tomoyo_readable_file" list.
- *
- * @filename:  Filename unconditionally permitted to open() for reading.
- * @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_globally_readable_entry(const char *filename,
-                                                 const bool is_delete)
-{
-        struct tomoyo_readable_file e = { };
-        int error;
-
-        if (!tomoyo_correct_word(filename))
-                return -EINVAL;
-        e.filename = tomoyo_get_name(filename);
-        if (!e.filename)
-                return -ENOMEM;
-        error = tomoyo_update_policy(&e.head, sizeof(e), is_delete,
-                                     &tomoyo_policy_list
-                                     [TOMOYO_ID_GLOBALLY_READABLE],
-                                     tomoyo_same_globally_readable);
-        tomoyo_put_name(e.filename);
-        return error;
-}
-
-/**
- * tomoyo_globally_readable_file - Check if the file is unconditionnaly permitted to be open()ed for reading.
- *
- * @filename: The filename to check.
- *
- * Returns true if any domain can open @filename for reading, false otherwise.
- *
- * Caller holds tomoyo_read_lock().
- */
-static bool tomoyo_globally_readable_file(const struct tomoyo_path_info *
-                                             filename)
-{
-        struct tomoyo_readable_file *ptr;
-        bool found = false;
-
-        list_for_each_entry_rcu(ptr, &tomoyo_policy_list
-                                [TOMOYO_ID_GLOBALLY_READABLE], head.list) {
-                if (!ptr->head.is_deleted &&
-                    tomoyo_path_matches_pattern(filename, ptr->filename)) {
-                        found = true;
-                        break;
-                }
-        }
-        return found;
-}
-
-/**
- * tomoyo_write_globally_readable - Write "struct tomoyo_readable_file" list.
- *
- * @data:      String to parse.
- * @is_delete: True if it is a delete request.
- *
- * Returns 0 on success, negative value otherwise.
- *
- * Caller holds tomoyo_read_lock().
- */
-int tomoyo_write_globally_readable(char *data, const bool is_delete)
-{
-        return tomoyo_update_globally_readable_entry(data, is_delete);
-}
-
-static bool tomoyo_same_pattern(const struct tomoyo_acl_head *a,
-                                const struct tomoyo_acl_head *b)
-{
-        return container_of(a, struct tomoyo_no_pattern, head)->pattern ==
-                container_of(b, struct tomoyo_no_pattern, head)->pattern;
-}
-
-/**
- * tomoyo_update_file_pattern_entry - Update "struct tomoyo_no_pattern" list.
- *
- * @pattern:   Pathname pattern.
- * @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_file_pattern_entry(const char *pattern,
-                                            const bool is_delete)
-{
-        struct tomoyo_no_pattern e = { };
-        int error;
-
-        if (!tomoyo_correct_word(pattern))
-                return -EINVAL;
-        e.pattern = tomoyo_get_name(pattern);
-        if (!e.pattern)
-                return -ENOMEM;
-        error = tomoyo_update_policy(&e.head, sizeof(e), is_delete,
-                                     &tomoyo_policy_list[TOMOYO_ID_PATTERN],
-                                     tomoyo_same_pattern);
-        tomoyo_put_name(e.pattern);
-        return error;
-}
-
-/**
- * tomoyo_pattern - Get patterned pathname.
- *
- * @filename: The filename to find patterned pathname.
- *
- * Returns pointer to pathname pattern if matched, @filename otherwise.
- *
- * Caller holds tomoyo_read_lock().
- */
-const char *tomoyo_pattern(const struct tomoyo_path_info *filename)
-{
-        struct tomoyo_no_pattern *ptr;
-        const struct tomoyo_path_info *pattern = NULL;
-
-        list_for_each_entry_rcu(ptr, &tomoyo_policy_list[TOMOYO_ID_PATTERN],
-                                head.list) {
-                if (ptr->head.is_deleted)
-                        continue;
-                if (!tomoyo_path_matches_pattern(filename, ptr->pattern))
-                        continue;
-                pattern = ptr->pattern;
-                if (tomoyo_strendswith(pattern->name, "/\\*")) {
-                        /* Do nothing. Try to find the better match. */
-                } else {
-                        /* This would be the better match. Use this. */
-                        break;
-                }
-        }
-        if (pattern)
-                filename = pattern;
-        return filename->name;
-}
-
-/**
- * tomoyo_write_pattern - Write "struct tomoyo_no_pattern" list.
- *
- * @data:      String to parse.
- * @is_delete: True if it is a delete request.
- *
- * Returns 0 on success, negative value otherwise.
- *
- * Caller holds tomoyo_read_lock().
- */
-int tomoyo_write_pattern(char *data, const bool is_delete)
-{
-        return tomoyo_update_file_pattern_entry(data, is_delete);
-}
-
-static bool tomoyo_same_no_rewrite(const struct tomoyo_acl_head *a,
-                                   const struct tomoyo_acl_head *b)
-{
-        return container_of(a, struct tomoyo_no_rewrite, head)->pattern
-                == container_of(b, struct tomoyo_no_rewrite, head)
-                ->pattern;
-}
-
-/**
- * tomoyo_update_no_rewrite_entry - Update "struct tomoyo_no_rewrite" list.
- *
- * @pattern:   Pathname pattern that are not rewritable by default.
- * @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_no_rewrite_entry(const char *pattern,
-                                          const bool is_delete)
-{
-        struct tomoyo_no_rewrite e = { };
-        int error;
-
-        if (!tomoyo_correct_word(pattern))
-                return -EINVAL;
-        e.pattern = tomoyo_get_name(pattern);
-        if (!e.pattern)
-                return -ENOMEM;
-        error = tomoyo_update_policy(&e.head, sizeof(e), is_delete,
-                                     &tomoyo_policy_list[TOMOYO_ID_NO_REWRITE],
-                                     tomoyo_same_no_rewrite);
-        tomoyo_put_name(e.pattern);
-        return error;
+        return tomoyo_supervisor(r, "file %s %s %s\n", tomoyo_mac_keywords
+                                 [tomoyo_pn2mac[type]],
+                                 r->param.path_number.filename->name, buffer);
 }
 
 /**
- * tomoyo_no_rewrite_file - Check if the given pathname is not permitted to be rewrited.
+ * tomoyo_check_path_acl - Check permission for path operation.
  *
- * @filename: Filename to check.
+ * @r:   Pointer to "struct tomoyo_request_info".
+ * @ptr: Pointer to "struct tomoyo_acl_info".
  *
- * Returns true if @filename is specified by "deny_rewrite" directive,
- * false otherwise.
+ * Returns true if granted, false otherwise.
  *
- * Caller holds tomoyo_read_lock().
+ * 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_no_rewrite_file(const struct tomoyo_path_info *filename)
-{
-        struct tomoyo_no_rewrite *ptr;
-        bool found = false;
-
-        list_for_each_entry_rcu(ptr, &tomoyo_policy_list[TOMOYO_ID_NO_REWRITE],
-                                head.list) {
-                if (ptr->head.is_deleted)
-                        continue;
-                if (!tomoyo_path_matches_pattern(filename, ptr->pattern))
-                        continue;
-                found = true;
-                break;
-        }
-        return found;
-}
-
-/**
- * tomoyo_write_no_rewrite - Write "struct tomoyo_no_rewrite" list.
- *
- * @data:      String to parse.
- * @is_delete: True if it is a delete request.
- *
- * Returns 0 on success, negative value otherwise.
- *
- * Caller holds tomoyo_read_lock().
- */
-int tomoyo_write_no_rewrite(char *data, const bool is_delete)
-{
-        return tomoyo_update_no_rewrite_entry(data, is_delete);
-}
-
 static bool tomoyo_check_path_acl(struct tomoyo_request_info *r,
                                   const struct tomoyo_acl_info *ptr)
 {
@@ -521,6 +261,14 @@ static bool tomoyo_check_path_acl(struct tomoyo_request_info *r,
         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)
 {
@@ -533,6 +281,14 @@ static bool tomoyo_check_path_number_acl(struct tomoyo_request_info *r,
                                           &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)
 {
@@ -544,8 +300,16 @@ static bool tomoyo_check_path2_acl(struct tomoyo_request_info *r,
                                              &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_acl_info *ptr)
 {
         const struct tomoyo_mkdev_acl *acl =
                 container_of(ptr, typeof(*acl), head);
@@ -560,15 +324,31 @@ static bool tomoyo_check_mkdev_acl(struct tomoyo_request_info *r,
                                           &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_acl_head(&p1->head, &p2->head) &&
-                tomoyo_same_name_union(&p1->name, &p2->name);
+        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)
@@ -577,19 +357,10 @@ static bool tomoyo_merge_path_acl(struct tomoyo_acl_info *a,
                 ->perm;
         u16 perm = *a_perm;
         const u16 b_perm = container_of(b, struct tomoyo_path_acl, head)->perm;
-        if (is_delete) {
+        if (is_delete)
                 perm &= ~b_perm;
-                if ((perm & TOMOYO_RW_MASK) != TOMOYO_RW_MASK)
-                        perm &= ~(1 << TOMOYO_TYPE_READ_WRITE);
-                else if (!(perm & (1 << TOMOYO_TYPE_READ_WRITE)))
-                        perm &= ~TOMOYO_RW_MASK;
-        } else {
+        else
                 perm |= b_perm;
-                if ((perm & TOMOYO_RW_MASK) == TOMOYO_RW_MASK)
-                        perm |= (1 << TOMOYO_TYPE_READ_WRITE);
-                else if (perm & (1 << TOMOYO_TYPE_READ_WRITE))
-                        perm |= TOMOYO_RW_MASK;
-        }
         *a_perm = perm;
         return !perm;
 }
@@ -597,52 +368,62 @@ static bool tomoyo_merge_path_acl(struct tomoyo_acl_info *a,
 /**
  * tomoyo_update_path_acl - Update "struct tomoyo_path_acl" list.
  *
- * @type:      Type of operation.
- * @filename:  Filename.
- * @domain:    Pointer to "struct tomoyo_domain_info".
- * @is_delete: True if it is a delete request.
+ * @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 u8 type, const char *filename,
-                                  struct tomoyo_domain_info * const domain,
-                                  const bool is_delete)
+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 = 1 << type
+                .perm = perm
         };
         int error;
-        if (e.perm == (1 << TOMOYO_TYPE_READ_WRITE))
-                e.perm |= TOMOYO_RW_MASK;
-        if (!tomoyo_parse_name_union(filename, &e.name))
-                return -EINVAL;
-        error = tomoyo_update_domain(&e.head, sizeof(e), is_delete, domain,
-                                     tomoyo_same_path_acl,
-                                     tomoyo_merge_path_acl);
+        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_acl_head(&p1->head, &p2->head)
-                && 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);
+        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)
+                                   struct tomoyo_acl_info *b,
+                                   const bool is_delete)
 {
         u8 *const a_perm = &container_of(a, struct tomoyo_mkdev_acl,
                                          head)->perm;
@@ -660,37 +441,30 @@ static bool tomoyo_merge_mkdev_acl(struct tomoyo_acl_info *a,
 /**
  * tomoyo_update_mkdev_acl - Update "struct tomoyo_mkdev_acl" list.
  *
- * @type:      Type of operation.
- * @filename:  Filename.
- * @mode:      Create mode.
- * @major:     Device major number.
- * @minor:     Device minor number.
- * @domain:    Pointer to "struct tomoyo_domain_info".
- * @is_delete: True if it is a delete request.
+ * @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 type, const char *filename,
-                                          char *mode, char *major, char *minor,
-                                          struct tomoyo_domain_info * const
-                                          domain, const bool is_delete)
+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 = 1 << type
+                .perm = perm
         };
-        int error = is_delete ? -ENOENT : -ENOMEM;
-        if (!tomoyo_parse_name_union(filename, &e.name) ||
-            !tomoyo_parse_number_union(mode, &e.mode) ||
-            !tomoyo_parse_number_union(major, &e.major) ||
-            !tomoyo_parse_number_union(minor, &e.minor))
-                goto out;
-        error = tomoyo_update_domain(&e.head, sizeof(e), is_delete, domain,
-                                     tomoyo_same_mkdev_acl,
-                                     tomoyo_merge_mkdev_acl);
- out:
+        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);
@@ -698,16 +472,32 @@ static int tomoyo_update_mkdev_acl(const u8 type, const char *filename,
         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_acl_head(&p1->head, &p2->head)
-                && tomoyo_same_name_union(&p1->name1, &p2->name1)
-                && tomoyo_same_name_union(&p1->name2, &p2->name2);
+        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)
@@ -727,33 +517,28 @@ static bool tomoyo_merge_path2_acl(struct tomoyo_acl_info *a,
 /**
  * tomoyo_update_path2_acl - Update "struct tomoyo_path2_acl" list.
  *
- * @type:      Type of operation.
- * @filename1: First filename.
- * @filename2: Second filename.
- * @domain:    Pointer to "struct tomoyo_domain_info".
- * @is_delete: True if it is a delete request.
+ * @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 type, const char *filename1,
-                                   const char *filename2,
-                                   struct tomoyo_domain_info * const domain,
-                                   const bool is_delete)
+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 = 1 << type
+                .perm = perm
         };
-        int error = is_delete ? -ENOENT : -ENOMEM;
-        if (!tomoyo_parse_name_union(filename1, &e.name1) ||
-            !tomoyo_parse_name_union(filename2, &e.name2))
-                goto out;
-        error = tomoyo_update_domain(&e.head, sizeof(e), is_delete, domain,
-                                     tomoyo_same_path2_acl,
-                                     tomoyo_merge_path2_acl);
- out:
+        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;
@@ -775,9 +560,8 @@ int tomoyo_path_permission(struct tomoyo_request_info *r, u8 operation,
 {
         int error;
 
- next:
         r->type = tomoyo_p2mac[operation];
-        r->mode = tomoyo_get_mode(r->profile, r->type);
+        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;
@@ -785,10 +569,6 @@ int tomoyo_path_permission(struct tomoyo_request_info *r, u8 operation,
         r->param.path.operation = operation;
         do {
                 tomoyo_check_acl(r, tomoyo_check_path_acl);
-                if (!r->granted && operation == TOMOYO_TYPE_READ &&
-                    !r->domain->ignore_global_allow_read &&
-                    tomoyo_globally_readable_file(filename))
-                        r->granted = true;
                 error = tomoyo_audit_path_log(r);
                 /*
                  * Do not retry for execute request, for alias may have
@@ -796,19 +576,17 @@ int tomoyo_path_permission(struct tomoyo_request_info *r, u8 operation,
                  */
         } while (error == TOMOYO_RETRY_REQUEST &&
                  operation != TOMOYO_TYPE_EXECUTE);
-        /*
-         * Since "allow_truncate" doesn't imply "allow_rewrite" permission,
-         * we need to check "allow_rewrite" permission if the filename is
-         * specified by "deny_rewrite" keyword.
-         */
-        if (!error && operation == TOMOYO_TYPE_TRUNCATE &&
-            tomoyo_no_rewrite_file(filename)) {
-                operation = TOMOYO_TYPE_REWRITE;
-                goto next;
-        }
         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)
 {
@@ -816,11 +594,19 @@ static bool tomoyo_same_path_number_acl(const struct tomoyo_acl_info *a,
                                                                head);
         const struct tomoyo_path_number_acl *p2 = container_of(b, typeof(*p2),
                                                                head);
-        return tomoyo_same_acl_head(&p1->head, &p2->head)
-                && tomoyo_same_name_union(&p1->name, &p2->name)
-                && tomoyo_same_number_union(&p1->number, &p2->number);
+        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)
@@ -841,33 +627,26 @@ static bool tomoyo_merge_path_number_acl(struct tomoyo_acl_info *a,
 /**
  * tomoyo_update_path_number_acl - Update ioctl/chmod/chown/chgrp ACL.
  *
- * @type:      Type of operation.
- * @filename:  Filename.
- * @number:    Number.
- * @domain:    Pointer to "struct tomoyo_domain_info".
- * @is_delete: True if it is a delete request.
+ * @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 type, const char *filename,
-                                         char *number,
-                                         struct tomoyo_domain_info * const
-                                         domain,
-                                         const bool is_delete)
+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 = 1 << type
+                .perm = perm
         };
-        int error = is_delete ? -ENOENT : -ENOMEM;
-        if (!tomoyo_parse_name_union(filename, &e.name))
-                return -EINVAL;
-        if (!tomoyo_parse_number_union(number, &e.number))
-                goto out;
-        error = tomoyo_update_domain(&e.head, sizeof(e), is_delete, domain,
-                                     tomoyo_same_path_number_acl,
-                                     tomoyo_merge_path_number_acl);
- out:
+        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;
@@ -886,16 +665,20 @@ 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->mnt || !path->dentry)
+            == 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;
@@ -930,45 +713,30 @@ int tomoyo_check_open_permission(struct tomoyo_domain_info *domain,
         int error = 0;
         struct tomoyo_path_info buf;
         struct tomoyo_request_info r;
+        struct tomoyo_obj_info obj = {
+                .path1 = *path,
+        };
         int idx;
 
-        if (!path->mnt ||
-            (path->dentry->d_inode && S_ISDIR(path->dentry->d_inode->i_mode)))
-                return 0;
         buf.name = NULL;
         r.mode = TOMOYO_CONFIG_DISABLED;
         idx = tomoyo_read_lock();
-        /*
-         * If the filename is specified by "deny_rewrite" keyword,
-         * we need to check "allow_rewrite" permission when the filename is not
-         * opened for append mode or the filename is truncated at open time.
-         */
-        if ((acc_mode & MAY_WRITE) && !(flag & O_APPEND)
-            && tomoyo_init_request_info(&r, domain, TOMOYO_MAC_FILE_REWRITE)
+        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;
                 }
-                if (tomoyo_no_rewrite_file(&buf))
-                        error = tomoyo_path_permission(&r, TOMOYO_TYPE_REWRITE,
+                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);
-        }
-        if (!error && acc_mode &&
-            tomoyo_init_request_info(&r, domain, TOMOYO_MAC_FILE_OPEN)
-            != TOMOYO_CONFIG_DISABLED) {
-                u8 operation;
-                if (!buf.name && !tomoyo_get_realpath(&buf, path)) {
-                        error = -ENOMEM;
-                        goto out;
-                }
-                if (acc_mode == (MAY_READ | MAY_WRITE))
-                        operation = TOMOYO_TYPE_READ_WRITE;
-                else if (acc_mode == MAY_READ)
-                        operation = TOMOYO_TYPE_READ;
-                else
-                        operation = TOMOYO_TYPE_WRITE;
-                error = tomoyo_path_permission(&r, operation, &buf);
         }
  out:
         kfree(buf.name);
@@ -979,46 +747,57 @@ int tomoyo_check_open_permission(struct tomoyo_domain_info *domain,
 }
 
 /**
- * tomoyo_path_perm - Check permission for "unlink", "rmdir", "truncate", "symlink", "rewrite", "chroot" and "unmount".
+ * 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)
+int tomoyo_path_perm(const u8 operation, struct path *path, const char *target)
 {
-        int error = -ENOMEM;
-        struct tomoyo_path_info buf;
         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 (!path->mnt)
-                return 0;
         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_REWRITE:
-                if (!tomoyo_no_rewrite_file(&buf)) {
-                        error = 0;
-                        goto out;
-                }
-                break;
         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 (r.mode != TOMOYO_CONFIG_ENFORCING)
+        if (!is_enforce)
                 error = 0;
         return error;
 }
@@ -1034,20 +813,23 @@ int tomoyo_path_perm(const u8 operation, struct path *path)
  * Returns 0 on success, negative value otherwise.
  */
 int tomoyo_mkdev_perm(const u8 operation, struct path *path,
-                             const unsigned int mode, unsigned int dev)
+                      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 (!path->mnt ||
-            tomoyo_init_request_info(&r, NULL, tomoyo_pnnn2mac[operation])
+        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;
@@ -1081,10 +863,13 @@ int tomoyo_path2_perm(const u8 operation, struct path *path1,
         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 (!path1->mnt || !path2->mnt ||
-            tomoyo_init_request_info(&r, NULL, tomoyo_pp2mac[operation])
+        if (tomoyo_init_request_info(&r, NULL, tomoyo_pp2mac[operation])
             == TOMOYO_CONFIG_DISABLED)
                 return 0;
         buf1.name = NULL;
@@ -1096,16 +881,17 @@ int tomoyo_path2_perm(const u8 operation, struct path *path1,
         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))
-                        break;
-                /* fall through */
-        case TOMOYO_TYPE_PIVOT_ROOT:
-                tomoyo_add_slash(&buf1);
-                tomoyo_add_slash(&buf2);
+                if (!dentry->d_inode || !S_ISDIR(dentry->d_inode->i_mode))
+                        break;
+                /* fall through */
+        case TOMOYO_TYPE_PIVOT_ROOT:
+                tomoyo_add_slash(&buf1);
+                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;
@@ -1124,53 +910,91 @@ int tomoyo_path2_perm(const u8 operation, struct path *path1,
 }
 
 /**
+ * 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.
  *
- * @data:      String to parse.
- * @domain:    Pointer to "struct tomoyo_domain_info".
- * @is_delete: True if it is a delete request.
+ * @param: Pointer to "struct tomoyo_acl_param".
  *
  * Returns 0 on success, negative value otherwise.
  *
  * Caller holds tomoyo_read_lock().
  */
-int tomoyo_write_file(char *data, struct tomoyo_domain_info *domain,
-                      const bool is_delete)
+int tomoyo_write_file(struct tomoyo_acl_param *param)
 {
-        char *w[5];
+        u16 perm = 0;
         u8 type;
-        if (!tomoyo_tokenize(data, w, sizeof(w)) || !w[1][0])
-                return -EINVAL;
-        if (strncmp(w[0], "allow_", 6))
-                goto out;
-        w[0] += 6;
-        for (type = 0; type < TOMOYO_MAX_PATH_OPERATION; type++) {
-                if (strcmp(w[0], tomoyo_path_keyword[type]))
-                        continue;
-                return tomoyo_update_path_acl(type, w[1], domain, is_delete);
-        }
-        if (!w[2][0])
-                goto out;
-        for (type = 0; type < TOMOYO_MAX_PATH2_OPERATION; type++) {
-                if (strcmp(w[0], tomoyo_path2_keyword[type]))
-                        continue;
-                return tomoyo_update_path2_acl(type, w[1], w[2], domain,
-                                               is_delete);
-        }
-        for (type = 0; type < TOMOYO_MAX_PATH_NUMBER_OPERATION; type++) {
-                if (strcmp(w[0], tomoyo_path_number_keyword[type]))
-                        continue;
-                return tomoyo_update_path_number_acl(type, w[1], w[2], domain,
-                                                     is_delete);
-        }
-        if (!w[3][0] || !w[4][0])
-                goto out;
-        for (type = 0; type < TOMOYO_MAX_MKDEV_OPERATION; type++) {
-                if (strcmp(w[0], tomoyo_mkdev_keyword[type]))
-                        continue;
-                return tomoyo_update_mkdev_acl(type, w[1], w[2], w[3],
-                                               w[4], domain, is_delete);
-        }
- out:
+        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;
 }
diff --git a/security/tomoyo/gc.c b/security/tomoyo/gc.c
index a877e4c3b10..ae135fbbbe9 100644
--- a/security/tomoyo/gc.c
+++ b/security/tomoyo/gc.c
@@ -1,58 +1,205 @@
 /*
  * security/tomoyo/gc.c
  *
- * Implementation of the Domain-Based Mandatory Access Control.
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
- *
+ * Copyright (C) 2005-2011  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;
-        int type;
+        enum tomoyo_policy_id type;
+        size_t size;
         struct list_head *element;
 };
-static LIST_HEAD(tomoyo_gc_queue);
-static DEFINE_MUTEX(tomoyo_gc_mutex);
+/* List of entries to be deleted. */
+static LIST_HEAD(tomoyo_gc_list);
+/* Length of tomoyo_gc_list. */
+static int tomoyo_gc_list_len;
 
-/* Caller holds tomoyo_policy_lock mutex. */
+/**
+ * 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_queue);
+        list_add(&entry->list, &tomoyo_gc_list);
         list_del_rcu(element);
-        return true;
+        return tomoyo_gc_list_len++ < 128;
 }
 
-static void tomoyo_del_allow_read(struct list_head *element)
-{
-        struct tomoyo_readable_file *ptr =
-                container_of(element, typeof(*ptr), head.list);
-        tomoyo_put_name(ptr->filename);
-}
-
-static void tomoyo_del_file_pattern(struct list_head *element)
-{
-        struct tomoyo_no_pattern *ptr =
-                container_of(element, typeof(*ptr), head.list);
-        tomoyo_put_name(ptr->pattern);
-}
-
-static void tomoyo_del_no_rewrite(struct list_head *element)
+/**
+ * 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_no_rewrite *ptr =
-                container_of(element, typeof(*ptr), head.list);
-        tomoyo_put_name(ptr->pattern);
+        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 =
@@ -61,6 +208,13 @@ static void tomoyo_del_transition_control(struct list_head *element)
         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 =
@@ -69,6 +223,13 @@ static void tomoyo_del_aggregator(struct list_head *element)
         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 =
@@ -76,10 +237,18 @@ static void tomoyo_del_manager(struct list_head *element)
         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:
                 {
@@ -127,6 +296,13 @@ static void tomoyo_del_acl(struct list_head *element)
         }
 }
 
+/**
+ * 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 =
@@ -165,13 +341,65 @@ static bool tomoyo_del_domain(struct list_head *element)
         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), list);
+                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 =
@@ -179,20 +407,43 @@ static void tomoyo_del_path_group(struct list_head *element)
         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), list);
+                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);
 }
 
-static bool tomoyo_collect_member(struct list_head *member_list, int id)
+/**
+ * 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) {
@@ -201,13 +452,20 @@ static bool tomoyo_collect_member(struct list_head *member_list, int id)
                 if (!tomoyo_add_to_gc(id, &member->list))
                         return false;
         }
-        return true;
+        return true;
 }
 
-static bool tomoyo_collect_acl(struct tomoyo_domain_info *domain)
+/**
+ * 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, &domain->acl_info_list, list) {
+        list_for_each_entry(acl, list, list) {
                 if (!acl->is_deleted)
                         continue;
                 if (!tomoyo_add_to_gc(TOMOYO_ID_ACL, &acl->list))
@@ -216,19 +474,24 @@ static bool tomoyo_collect_acl(struct tomoyo_domain_info *domain)
         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;
-        for (i = 0; i < TOMOYO_MAX_POLICY; i++) {
-                if (!tomoyo_collect_member(&tomoyo_policy_list[i], i))
-                        goto unlock;
-        }
+        idx = tomoyo_read_lock();
         {
                 struct tomoyo_domain_info *domain;
                 list_for_each_entry_rcu(domain, &tomoyo_domain_list, list) {
-                        if (!tomoyo_collect_acl(domain))
+                        if (!tomoyo_collect_acl(&domain->acl_info_list))
                                 goto unlock;
                         if (!domain->is_deleted || atomic_read(&domain->users))
                                 continue;
@@ -241,48 +504,93 @@ static void tomoyo_collect_entry(void)
                                 goto unlock;
                 }
         }
-        for (i = 0; i < TOMOYO_MAX_HASH; i++) {
-                struct tomoyo_name *ptr;
-                list_for_each_entry_rcu(ptr, &tomoyo_name_list[i], list) {
-                        if (atomic_read(&ptr->users))
-                                continue;
-                        if (!tomoyo_add_to_gc(TOMOYO_ID_NAME, &ptr->list))
+        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;
+                        }
                 }
         }
-        for (i = 0; i < TOMOYO_MAX_GROUP; i++) {
-                struct list_head *list = &tomoyo_group_list[i];
-                int id;
-                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, list) {
-                        if (!tomoyo_collect_member(&group->member_list, id))
-                                goto unlock;
-                        if (!list_empty(&group->member_list) ||
-                            atomic_read(&group->users))
+        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(TOMOYO_ID_GROUP, &group->list))
+                        if (!tomoyo_add_to_gc(id, &ptr->list))
                                 goto unlock;
                 }
+                id = TOMOYO_ID_NAME;
         }
- unlock:
+unlock:
+        tomoyo_read_unlock(idx);
         mutex_unlock(&tomoyo_policy_lock);
 }
 
-static void tomoyo_kfree_entry(void)
+/**
+ * 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_queue, list) {
+        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);
@@ -290,19 +598,21 @@ static void tomoyo_kfree_entry(void)
                 case TOMOYO_ID_AGGREGATOR:
                         tomoyo_del_aggregator(element);
                         break;
-                case TOMOYO_ID_GLOBALLY_READABLE:
-                        tomoyo_del_allow_read(element);
-                        break;
-                case TOMOYO_ID_PATTERN:
-                        tomoyo_del_file_pattern(element);
-                        break;
-                case TOMOYO_ID_NO_REWRITE:
-                        tomoyo_del_no_rewrite(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:
@@ -321,34 +631,95 @@ static void tomoyo_kfree_entry(void)
                 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");
-        if (mutex_trylock(&tomoyo_gc_mutex)) {
-                int i;
-                for (i = 0; i < 10; i++) {
-                        tomoyo_collect_entry();
-                        if (list_empty(&tomoyo_gc_queue))
-                                break;
-                        synchronize_srcu(&tomoyo_ss);
-                        tomoyo_kfree_entry();
+        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);
                 }
-                mutex_unlock(&tomoyo_gc_mutex);
+                spin_unlock(&tomoyo_io_buffer_list_lock);
         }
-        do_exit(0);
+        mutex_unlock(&tomoyo_gc_mutex);
+out:
+        /* This acts as do_exit(0). */
+        return 0;
 }
 
-void tomoyo_run_gc(void)
+/**
+ * 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)
 {
-        struct task_struct *task = kthread_create(tomoyo_gc_thread, NULL,
-                                                  "GC for TOMOYO");
-        if (!IS_ERR(task))
-                wake_up_process(task);
+        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);
+        }
 }
diff --git a/security/tomoyo/group.c b/security/tomoyo/group.c
index e94352ce723..5fb0e129840 100644
--- a/security/tomoyo/group.c
+++ b/security/tomoyo/group.c
@@ -1,21 +1,37 @@
 /*
  * 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,
@@ -28,48 +44,41 @@ static bool tomoyo_same_number_group(const struct tomoyo_acl_head *a,
 /**
  * tomoyo_write_group - Write "struct tomoyo_path_group"/"struct tomoyo_number_group" list.
  *
- * @data:      String to parse.
- * @is_delete: True if it is a delete request.
- * @type:      Type of this group.
+ * @param: Pointer to "struct tomoyo_acl_param".
+ * @type:  Type of this group.
  *
  * Returns 0 on success, negative value otherwise.
  */
-int tomoyo_write_group(char *data, const bool is_delete, const u8 type)
+int tomoyo_write_group(struct tomoyo_acl_param *param, const u8 type)
 {
-        struct tomoyo_group *group;
-        struct list_head *member;
-        char *w[2];
+        struct tomoyo_group *group = tomoyo_get_group(param, type);
         int error = -EINVAL;
-        if (!tomoyo_tokenize(data, w, sizeof(w)) || !w[1][0])
-                return -EINVAL;
-        group = tomoyo_get_group(w[0], type);
         if (!group)
                 return -ENOMEM;
-        member = &group->member_list;
+        param->list = &group->member_list;
         if (type == TOMOYO_PATH_GROUP) {
                 struct tomoyo_path_group e = { };
-                e.member_name = tomoyo_get_name(w[1]);
+                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), is_delete,
-                                             member, tomoyo_same_path_group);
+                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 (w[1][0] == '@'
-                    || !tomoyo_parse_number_union(w[1], &e.number)
-                    || e.number.values[0] > e.number.values[1])
+                if (param->data[0] == '@' ||
+                    !tomoyo_parse_number_union(param, &e.number))
                         goto out;
-                error = tomoyo_update_policy(&e.head, sizeof(e), is_delete,
-                                             member, tomoyo_same_number_group);
+                error = tomoyo_update_policy(&e.head, sizeof(e), param,
+                                          tomoyo_same_number_group);
                 /*
                  * tomoyo_put_number_union() is not needed because
-                 * w[1][0] != '@'.
+                 * param->data[0] != '@'.
                  */
         }
- out:
+out:
         tomoyo_put_group(group);
         return error;
 }
@@ -77,8 +86,8 @@ int tomoyo_write_group(char *data, const bool is_delete, const u8 type)
 /**
  * tomoyo_path_matches_group - Check whether the given pathname matches members of the given pathname group.
  *
- * @pathname:        The name of pathname.
- * @group:           Pointer to "struct tomoyo_path_group".
+ * @pathname: The name of pathname.
+ * @group:    Pointer to "struct tomoyo_path_group".
  *
  * Returns matched member's pathname if @pathname matches pathnames in @group,
  * NULL otherwise.
diff --git a/security/tomoyo/load_policy.c b/security/tomoyo/load_policy.c
index 3312e5624f2..67975405140 100644
--- a/security/tomoyo/load_policy.c
+++ b/security/tomoyo/load_policy.c
@@ -1,15 +1,32 @@
 /*
  * security/tomoyo/load_policy.c
  *
- * Policy loader launcher for TOMOYO.
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
  */
 
 #include "common.h"
 
-/* path to policy loader */
-static const char *tomoyo_loader = "/sbin/tomoyo-init";
+#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.
@@ -18,24 +35,38 @@ static const char *tomoyo_loader = "/sbin/tomoyo-init";
  */
 static bool tomoyo_policy_loader_exists(void)
 {
-        /*
-         * Don't activate MAC if the policy loader doesn't exist.
-         * If the initrd includes /sbin/init but real-root-dev has not
-         * mounted on / yet, activating MAC will block the system since
-         * policies are not loaded yet.
-         * Thus, let do_execve() call this function every time.
-         */
         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 now "
-                       "since %s doesn't exist.\n", tomoyo_loader);
+                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.
  *
@@ -51,24 +82,19 @@ static bool tomoyo_policy_loader_exists(void)
  */
 void tomoyo_load_policy(const char *filename)
 {
+        static bool done;
         char *argv[2];
         char *envp[3];
 
-        if (tomoyo_policy_loaded)
+        if (tomoyo_policy_loaded || done)
                 return;
-        /*
-         * Check filename is /sbin/init or /sbin/tomoyo-start.
-         * /sbin/tomoyo-start is a dummy filename in case where /sbin/init can't
-         * be passed.
-         * You can create /sbin/tomoyo-start by
-         * "ln -s /bin/true /sbin/tomoyo-start".
-         */
-        if (strcmp(filename, "/sbin/init") &&
-            strcmp(filename, "/sbin/tomoyo-start"))
+        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;
@@ -79,3 +105,5 @@ void tomoyo_load_policy(const char *filename)
         call_usermodehelper(argv[0], argv, envp, 1);
         tomoyo_check_profile();
 }
+
+#endif
diff --git a/security/tomoyo/memory.c b/security/tomoyo/memory.c
index 42a7b1ba8cb..7a56051146c 100644
--- a/security/tomoyo/memory.c
+++ b/security/tomoyo/memory.c
@@ -1,9 +1,7 @@
 /*
  * security/tomoyo/memory.c
  *
- * Memory management functions for TOMOYO.
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
  */
 
 #include <linux/hash.h>
@@ -29,10 +27,12 @@ void tomoyo_warn_oom(const char *function)
                 panic("MAC Initialization failed.\n");
 }
 
-/* Memory allocated for policy. */
-static atomic_t tomoyo_policy_memory_size;
-/* Quota for holding policy. */
-static unsigned int tomoyo_quota_for_policy;
+/* 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.
@@ -45,15 +45,20 @@ static unsigned int tomoyo_quota_for_policy;
  */
 bool tomoyo_memory_ok(void *ptr)
 {
-        size_t s = ptr ? ksize(ptr) : 0;
-        atomic_add(s, &tomoyo_policy_memory_size);
-        if (ptr && (!tomoyo_quota_for_policy ||
-                    atomic_read(&tomoyo_policy_memory_size)
-                    <= tomoyo_quota_for_policy)) {
-                memset(ptr, 0, s);
-                return true;
+        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;
         }
-        atomic_sub(s, &tomoyo_policy_memory_size);
         tomoyo_warn_oom(__func__);
         return false;
 }
@@ -86,22 +91,28 @@ void *tomoyo_commit_ok(void *data, const unsigned int size)
  */
 void tomoyo_memory_free(void *ptr)
 {
-        atomic_sub(ksize(ptr), &tomoyo_policy_memory_size);
+        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".
  *
- * @group_name: The name of address group.
- * @idx:        Index number.
+ * @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(const char *group_name, const u8 idx)
+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;
@@ -110,10 +121,11 @@ struct tomoyo_group *tomoyo_get_group(const char *group_name, const u8 idx)
                 return NULL;
         if (mutex_lock_interruptible(&tomoyo_policy_lock))
                 goto out;
-        list_for_each_entry(group, &tomoyo_group_list[idx], list) {
+        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->users);
+                atomic_inc(&group->head.users);
                 found = true;
                 break;
         }
@@ -121,15 +133,14 @@ struct tomoyo_group *tomoyo_get_group(const char *group_name, const u8 idx)
                 struct tomoyo_group *entry = tomoyo_commit_ok(&e, sizeof(e));
                 if (entry) {
                         INIT_LIST_HEAD(&entry->member_list);
-                        atomic_set(&entry->users, 1);
-                        list_add_tail_rcu(&entry->list,
-                                          &tomoyo_group_list[idx]);
+                        atomic_set(&entry->head.users, 1);
+                        list_add_tail_rcu(&entry->head.list, list);
                         group = entry;
                         found = true;
                 }
         }
         mutex_unlock(&tomoyo_policy_lock);
- out:
+out:
         tomoyo_put_name(e.group_name);
         return found ? group : NULL;
 }
@@ -154,7 +165,6 @@ const struct tomoyo_path_info *tomoyo_get_name(const char *name)
         struct tomoyo_name *ptr;
         unsigned int hash;
         int len;
-        int allocated_len;
         struct list_head *head;
 
         if (!name)
@@ -164,120 +174,43 @@ const struct tomoyo_path_info *tomoyo_get_name(const char *name)
         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, list) {
+        list_for_each_entry(ptr, head, head.list) {
                 if (hash != ptr->entry.hash || strcmp(name, ptr->entry.name))
                         continue;
-                atomic_inc(&ptr->users);
+                atomic_inc(&ptr->head.users);
                 goto out;
         }
         ptr = kzalloc(sizeof(*ptr) + len, GFP_NOFS);
-        allocated_len = ptr ? ksize(ptr) : 0;
-        if (!ptr || (tomoyo_quota_for_policy &&
-                     atomic_read(&tomoyo_policy_memory_size) + allocated_len
-                     > tomoyo_quota_for_policy)) {
+        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;
-                tomoyo_warn_oom(__func__);
-                goto out;
         }
-        atomic_add(allocated_len, &tomoyo_policy_memory_size);
-        ptr->entry.name = ((char *) ptr) + sizeof(*ptr);
-        memmove((char *) ptr->entry.name, name, len);
-        atomic_set(&ptr->users, 1);
-        tomoyo_fill_path_info(&ptr->entry);
-        list_add_tail(&ptr->list, head);
- out:
+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_POLICY; idx++)
-                INIT_LIST_HEAD(&tomoyo_policy_list[idx]);
-        for (idx = 0; idx < TOMOYO_MAX_GROUP; idx++)
-                INIT_LIST_HEAD(&tomoyo_group_list[idx]);
         for (idx = 0; idx < TOMOYO_MAX_HASH; idx++)
                 INIT_LIST_HEAD(&tomoyo_name_list[idx]);
+        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(TOMOYO_ROOT_NAME);
+        tomoyo_kernel_domain.domainname = tomoyo_get_name("<kernel>");
         list_add_tail_rcu(&tomoyo_kernel_domain.list, &tomoyo_domain_list);
-        idx = tomoyo_read_lock();
-        if (tomoyo_find_domain(TOMOYO_ROOT_NAME) != &tomoyo_kernel_domain)
-                panic("Can't register tomoyo_kernel_domain");
-        {
-                /* Load built-in policy. */
-                tomoyo_write_transition_control("/sbin/hotplug", false,
-                                        TOMOYO_TRANSITION_CONTROL_INITIALIZE);
-                tomoyo_write_transition_control("/sbin/modprobe", false,
-                                        TOMOYO_TRANSITION_CONTROL_INITIALIZE);
-        }
-        tomoyo_read_unlock(idx);
-}
-
-
-/* Memory allocated for query lists. */
-unsigned int tomoyo_query_memory_size;
-/* Quota for holding query lists. */
-unsigned int tomoyo_quota_for_query;
-
-/**
- * tomoyo_read_memory_counter - Check for memory usage in bytes.
- *
- * @head: Pointer to "struct tomoyo_io_buffer".
- *
- * Returns memory usage.
- */
-void tomoyo_read_memory_counter(struct tomoyo_io_buffer *head)
-{
-        if (!head->r.eof) {
-                const unsigned int policy
-                        = atomic_read(&tomoyo_policy_memory_size);
-                const unsigned int query = tomoyo_query_memory_size;
-                char buffer[64];
-
-                memset(buffer, 0, sizeof(buffer));
-                if (tomoyo_quota_for_policy)
-                        snprintf(buffer, sizeof(buffer) - 1,
-                                 "   (Quota: %10u)",
-                                 tomoyo_quota_for_policy);
-                else
-                        buffer[0] = '\0';
-                tomoyo_io_printf(head, "Policy:       %10u%s\n", policy,
-                                 buffer);
-                if (tomoyo_quota_for_query)
-                        snprintf(buffer, sizeof(buffer) - 1,
-                                 "   (Quota: %10u)",
-                                 tomoyo_quota_for_query);
-                else
-                        buffer[0] = '\0';
-                tomoyo_io_printf(head, "Query lists:  %10u%s\n", query,
-                                 buffer);
-                tomoyo_io_printf(head, "Total:        %10u\n", policy + query);
-                head->r.eof = true;
-        }
-}
-
-/**
- * tomoyo_write_memory_quota - Set memory quota.
- *
- * @head: Pointer to "struct tomoyo_io_buffer".
- *
- * Returns 0.
- */
-int tomoyo_write_memory_quota(struct tomoyo_io_buffer *head)
-{
-        char *data = head->write_buf;
-        unsigned int size;
-
-        if (sscanf(data, "Policy: %u", &size) == 1)
-                tomoyo_quota_for_policy = size;
-        else if (sscanf(data, "Query lists: %u", &size) == 1)
-                tomoyo_quota_for_query = size;
-        return 0;
 }
diff --git a/security/tomoyo/mount.c b/security/tomoyo/mount.c
index 9fc2e15841c..bee09d06205 100644
--- a/security/tomoyo/mount.c
+++ b/security/tomoyo/mount.c
@@ -1,28 +1,22 @@
 /*
  * security/tomoyo/mount.c
  *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
  */
 
 #include <linux/slab.h>
 #include "common.h"
 
-/* Keywords for mount restrictions. */
-
-/* Allow to call 'mount --bind /source_dir /dest_dir' */
-#define TOMOYO_MOUNT_BIND_KEYWORD                        "--bind"
-/* Allow to call 'mount --move /old_dir    /new_dir ' */
-#define TOMOYO_MOUNT_MOVE_KEYWORD                        "--move"
-/* Allow to call 'mount -o remount /dir             ' */
-#define TOMOYO_MOUNT_REMOUNT_KEYWORD                     "--remount"
-/* Allow to call 'mount --make-unbindable /dir'       */
-#define TOMOYO_MOUNT_MAKE_UNBINDABLE_KEYWORD             "--make-unbindable"
-/* Allow to call 'mount --make-private /dir'          */
-#define TOMOYO_MOUNT_MAKE_PRIVATE_KEYWORD                "--make-private"
-/* Allow to call 'mount --make-slave /dir'            */
-#define TOMOYO_MOUNT_MAKE_SLAVE_KEYWORD                  "--make-slave"
-/* Allow to call 'mount --make-shared /dir'           */
-#define TOMOYO_MOUNT_MAKE_SHARED_KEYWORD                 "--make-shared"
+/* String table for special mount operations. */
+static const char * const tomoyo_mounts[TOMOYO_MAX_SPECIAL_MOUNT] = {
+        [TOMOYO_MOUNT_BIND]            = "--bind",
+        [TOMOYO_MOUNT_MOVE]            = "--move",
+        [TOMOYO_MOUNT_REMOUNT]         = "--remount",
+        [TOMOYO_MOUNT_MAKE_UNBINDABLE] = "--make-unbindable",
+        [TOMOYO_MOUNT_MAKE_PRIVATE]    = "--make-private",
+        [TOMOYO_MOUNT_MAKE_SLAVE]      = "--make-slave",
+        [TOMOYO_MOUNT_MAKE_SHARED]     = "--make-shared",
+};
 
 /**
  * tomoyo_audit_mount_log - Audit mount log.
@@ -33,50 +27,42 @@
  */
 static int tomoyo_audit_mount_log(struct tomoyo_request_info *r)
 {
-        const char *dev = r->param.mount.dev->name;
-        const char *dir = r->param.mount.dir->name;
-        const char *type = r->param.mount.type->name;
-        const unsigned long flags = r->param.mount.flags;
-        if (r->granted)
-                return 0;
-        if (!strcmp(type, TOMOYO_MOUNT_REMOUNT_KEYWORD))
-                tomoyo_warn_log(r, "mount -o remount %s 0x%lX", dir, flags);
-        else if (!strcmp(type, TOMOYO_MOUNT_BIND_KEYWORD)
-                 || !strcmp(type, TOMOYO_MOUNT_MOVE_KEYWORD))
-                tomoyo_warn_log(r, "mount %s %s %s 0x%lX", type, dev, dir,
-                                flags);
-        else if (!strcmp(type, TOMOYO_MOUNT_MAKE_UNBINDABLE_KEYWORD) ||
-                 !strcmp(type, TOMOYO_MOUNT_MAKE_PRIVATE_KEYWORD) ||
-                 !strcmp(type, TOMOYO_MOUNT_MAKE_SLAVE_KEYWORD) ||
-                 !strcmp(type, TOMOYO_MOUNT_MAKE_SHARED_KEYWORD))
-                tomoyo_warn_log(r, "mount %s %s 0x%lX", type, dir, flags);
-        else
-                tomoyo_warn_log(r, "mount -t %s %s %s 0x%lX", type, dev, dir,
-                                flags);
-        return tomoyo_supervisor(r,
-                                 TOMOYO_KEYWORD_ALLOW_MOUNT "%s %s %s 0x%lX\n",
-                                 tomoyo_pattern(r->param.mount.dev),
-                                 tomoyo_pattern(r->param.mount.dir), type,
-                                 flags);
+        return tomoyo_supervisor(r, "file mount %s %s %s 0x%lX\n",
+                                 r->param.mount.dev->name,
+                                 r->param.mount.dir->name,
+                                 r->param.mount.type->name,
+                                 r->param.mount.flags);
 }
 
+/**
+ * tomoyo_check_mount_acl - Check permission for path path 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_mount_acl(struct tomoyo_request_info *r,
                                    const struct tomoyo_acl_info *ptr)
 {
         const struct tomoyo_mount_acl *acl =
                 container_of(ptr, typeof(*acl), head);
-        return tomoyo_compare_number_union(r->param.mount.flags, &acl->flags) &&
-                tomoyo_compare_name_union(r->param.mount.type, &acl->fs_type) &&
-                tomoyo_compare_name_union(r->param.mount.dir, &acl->dir_name) &&
+        return tomoyo_compare_number_union(r->param.mount.flags,
+                                           &acl->flags) &&
+                tomoyo_compare_name_union(r->param.mount.type,
+                                          &acl->fs_type) &&
+                tomoyo_compare_name_union(r->param.mount.dir,
+                                          &acl->dir_name) &&
                 (!r->param.mount.need_dev ||
-                 tomoyo_compare_name_union(r->param.mount.dev, &acl->dev_name));
+                 tomoyo_compare_name_union(r->param.mount.dev,
+                                           &acl->dev_name));
 }
 
 /**
  * tomoyo_mount_acl - Check permission for mount() operation.
  *
  * @r:        Pointer to "struct tomoyo_request_info".
- * @dev_name: Name of device file.
+ * @dev_name: Name of device file. Maybe NULL.
  * @dir:      Pointer to "struct path".
  * @type:     Name of filesystem type.
  * @flags:    Mount options.
@@ -86,8 +72,10 @@ static bool tomoyo_check_mount_acl(struct tomoyo_request_info *r,
  * Caller holds tomoyo_read_lock().
  */
 static int tomoyo_mount_acl(struct tomoyo_request_info *r, char *dev_name,
-                            struct path *dir, char *type, unsigned long flags)
+                            struct path *dir, const char *type,
+                            unsigned long flags)
 {
+        struct tomoyo_obj_info obj = { };
         struct path path;
         struct file_system_type *fstype = NULL;
         const char *requested_type = NULL;
@@ -98,6 +86,7 @@ static int tomoyo_mount_acl(struct tomoyo_request_info *r, char *dev_name,
         struct tomoyo_path_info rdir;
         int need_dev = 0;
         int error = -ENOMEM;
+        r->obj = &obj;
 
         /* Get fstype. */
         requested_type = tomoyo_encode(type);
@@ -107,6 +96,7 @@ static int tomoyo_mount_acl(struct tomoyo_request_info *r, char *dev_name,
         tomoyo_fill_path_info(&rtype);
 
         /* Get mount point. */
+        obj.path2 = *dir;
         requested_dir_name = tomoyo_realpath_from_path(dir);
         if (!requested_dir_name) {
                 error = -ENOMEM;
@@ -116,15 +106,15 @@ static int tomoyo_mount_acl(struct tomoyo_request_info *r, char *dev_name,
         tomoyo_fill_path_info(&rdir);
 
         /* Compare fs name. */
-        if (!strcmp(type, TOMOYO_MOUNT_REMOUNT_KEYWORD)) {
+        if (type == tomoyo_mounts[TOMOYO_MOUNT_REMOUNT]) {
                 /* dev_name is ignored. */
-        } else if (!strcmp(type, TOMOYO_MOUNT_MAKE_UNBINDABLE_KEYWORD) ||
-                   !strcmp(type, TOMOYO_MOUNT_MAKE_PRIVATE_KEYWORD) ||
-                   !strcmp(type, TOMOYO_MOUNT_MAKE_SLAVE_KEYWORD) ||
-                   !strcmp(type, TOMOYO_MOUNT_MAKE_SHARED_KEYWORD)) {
+        } else if (type == tomoyo_mounts[TOMOYO_MOUNT_MAKE_UNBINDABLE] ||
+                   type == tomoyo_mounts[TOMOYO_MOUNT_MAKE_PRIVATE] ||
+                   type == tomoyo_mounts[TOMOYO_MOUNT_MAKE_SLAVE] ||
+                   type == tomoyo_mounts[TOMOYO_MOUNT_MAKE_SHARED]) {
                 /* dev_name is ignored. */
-        } else if (!strcmp(type, TOMOYO_MOUNT_BIND_KEYWORD) ||
-                   !strcmp(type, TOMOYO_MOUNT_MOVE_KEYWORD)) {
+        } else if (type == tomoyo_mounts[TOMOYO_MOUNT_BIND] ||
+                   type == tomoyo_mounts[TOMOYO_MOUNT_MOVE]) {
                 need_dev = -1; /* dev_name is a directory */
         } else {
                 fstype = get_fs_type(type);
@@ -142,8 +132,8 @@ static int tomoyo_mount_acl(struct tomoyo_request_info *r, char *dev_name,
                         error = -ENOENT;
                         goto out;
                 }
+                obj.path1 = path;
                 requested_dev_name = tomoyo_realpath_from_path(&path);
-                path_put(&path);
                 if (!requested_dev_name) {
                         error = -ENOENT;
                         goto out;
@@ -176,22 +166,26 @@ static int tomoyo_mount_acl(struct tomoyo_request_info *r, char *dev_name,
         if (fstype)
                 put_filesystem(fstype);
         kfree(requested_type);
+        /* Drop refcount obtained by kern_path(). */
+        if (obj.path1.dentry)
+                path_put(&obj.path1);
         return error;
 }
 
 /**
  * tomoyo_mount_permission - Check permission for mount() operation.
  *
- * @dev_name:  Name of device file.
+ * @dev_name:  Name of device file. Maybe NULL.
  * @path:      Pointer to "struct path".
- * @type:      Name of filesystem type. May be NULL.
+ * @type:      Name of filesystem type. Maybe NULL.
  * @flags:     Mount options.
- * @data_page: Optional data. May be NULL.
+ * @data_page: Optional data. Maybe NULL.
  *
  * Returns 0 on success, negative value otherwise.
  */
-int tomoyo_mount_permission(char *dev_name, struct path *path, char *type,
-                            unsigned long flags, void *data_page)
+int tomoyo_mount_permission(char *dev_name, struct path *path,
+                            const char *type, unsigned long flags,
+                            void *data_page)
 {
         struct tomoyo_request_info r;
         int error;
@@ -203,31 +197,31 @@ int tomoyo_mount_permission(char *dev_name, struct path *path, char *type,
         if ((flags & MS_MGC_MSK) == MS_MGC_VAL)
                 flags &= ~MS_MGC_MSK;
         if (flags & MS_REMOUNT) {
-                type = TOMOYO_MOUNT_REMOUNT_KEYWORD;
+                type = tomoyo_mounts[TOMOYO_MOUNT_REMOUNT];
                 flags &= ~MS_REMOUNT;
         }
         if (flags & MS_MOVE) {
-                type = TOMOYO_MOUNT_MOVE_KEYWORD;
+                type = tomoyo_mounts[TOMOYO_MOUNT_MOVE];
                 flags &= ~MS_MOVE;
         }
         if (flags & MS_BIND) {
-                type = TOMOYO_MOUNT_BIND_KEYWORD;
+                type = tomoyo_mounts[TOMOYO_MOUNT_BIND];
                 flags &= ~MS_BIND;
         }
         if (flags & MS_UNBINDABLE) {
-                type = TOMOYO_MOUNT_MAKE_UNBINDABLE_KEYWORD;
+                type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_UNBINDABLE];
                 flags &= ~MS_UNBINDABLE;
         }
         if (flags & MS_PRIVATE) {
-                type = TOMOYO_MOUNT_MAKE_PRIVATE_KEYWORD;
+                type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_PRIVATE];
                 flags &= ~MS_PRIVATE;
         }
         if (flags & MS_SLAVE) {
-                type = TOMOYO_MOUNT_MAKE_SLAVE_KEYWORD;
+                type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_SLAVE];
                 flags &= ~MS_SLAVE;
         }
         if (flags & MS_SHARED) {
-                type = TOMOYO_MOUNT_MAKE_SHARED_KEYWORD;
+                type = tomoyo_mounts[TOMOYO_MOUNT_MAKE_SHARED];
                 flags &= ~MS_SHARED;
         }
         if (!type)
@@ -237,49 +231,3 @@ int tomoyo_mount_permission(char *dev_name, struct path *path, char *type,
         tomoyo_read_unlock(idx);
         return error;
 }
-
-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_acl_head(&p1->head, &p2->head) &&
-                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_write_mount - Write "struct tomoyo_mount_acl" list.
- *
- * @data:      String to parse.
- * @domain:    Pointer to "struct tomoyo_domain_info".
- * @is_delete: True if it is a delete request.
- *
- * Returns 0 on success, negative value otherwise.
- *
- * Caller holds tomoyo_read_lock().
- */
-int tomoyo_write_mount(char *data, struct tomoyo_domain_info *domain,
-                       const bool is_delete)
-{
-        struct tomoyo_mount_acl e = { .head.type = TOMOYO_TYPE_MOUNT_ACL };
-        int error = is_delete ? -ENOENT : -ENOMEM;
-        char *w[4];
-        if (!tomoyo_tokenize(data, w, sizeof(w)) || !w[3][0])
-                return -EINVAL;
-        if (!tomoyo_parse_name_union(w[0], &e.dev_name) ||
-            !tomoyo_parse_name_union(w[1], &e.dir_name) ||
-            !tomoyo_parse_name_union(w[2], &e.fs_type) ||
-            !tomoyo_parse_number_union(w[3], &e.flags))
-                goto out;
-        error = tomoyo_update_domain(&e.head, sizeof(e), is_delete, domain,
-                                     tomoyo_same_mount_acl, NULL);
- out:
-        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;
-}
diff --git a/security/tomoyo/realpath.c b/security/tomoyo/realpath.c
index d1e05b04771..d46922db054 100644
--- a/security/tomoyo/realpath.c
+++ b/security/tomoyo/realpath.c
@@ -1,9 +1,7 @@
 /*
  * security/tomoyo/realpath.c
  *
- * Pathname calculation functions for TOMOYO.
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
  */
 
 #include <linux/types.h>
@@ -70,6 +68,160 @@ char *tomoyo_encode(const char *str)
 }
 
 /**
+ * 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) {
+                /* go to whatever namespace root we are under */
+                pos = d_absolute_path(path, 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".
@@ -90,55 +242,50 @@ char *tomoyo_realpath_from_path(struct path *path)
         char *name = NULL;
         unsigned int buf_len = PAGE_SIZE / 2;
         struct dentry *dentry = path->dentry;
-        bool is_dir;
+        struct super_block *sb;
         if (!dentry)
                 return NULL;
-        is_dir = dentry->d_inode && S_ISDIR(dentry->d_inode->i_mode);
+        sb = dentry->d_sb;
         while (1) {
-                struct path ns_root = { .mnt = NULL, .dentry = NULL };
                 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 (dentry->d_sb && dentry->d_sb->s_magic == SOCKFS_MAGIC) {
-                        struct inode *inode = dentry->d_inode;
-                        struct socket *sock = inode ? SOCKET_I(inode) : NULL;
-                        struct sock *sk = sock ? sock->sk : NULL;
-                        if (sk) {
-                                snprintf(buf, buf_len - 1, "socket:[family=%u:"
-                                         "type=%u:protocol=%u]", sk->sk_family,
-                                         sk->sk_type, sk->sk_protocol);
-                        } else {
-                                snprintf(buf, buf_len - 1, "socket:[unknown]");
-                        }
-                        name = tomoyo_encode(buf);
-                        break;
+                if (sb->s_magic == SOCKFS_MAGIC) {
+                        pos = tomoyo_get_socket_name(path, buf, buf_len - 1);
+                        goto encode;
                 }
-                /* For "socket:[\$]" and "pipe:[\$]". */
+                /* For "pipe:[\$]". */
                 if (dentry->d_op && dentry->d_op->d_dname) {
                         pos = dentry->d_op->d_dname(dentry, buf, buf_len - 1);
-                        if (IS_ERR(pos))
-                                continue;
-                        name = tomoyo_encode(pos);
-                        break;
+                        goto encode;
                 }
-                /* If we don't have a vfsmount, we can't calculate. */
-                if (!path->mnt)
-                        break;
-                /* go to whatever namespace root we are under */
-                pos = __d_path(path, &ns_root, buf, buf_len);
-                /* Prepend "/proc" prefix if using internal proc vfs mount. */
-                if (!IS_ERR(pos) && (path->mnt->mnt_flags & MNT_INTERNAL) &&
-                    (path->mnt->mnt_sb->s_magic == PROC_SUPER_MAGIC)) {
-                        pos -= 5;
-                        if (pos >= buf)
-                                memcpy(pos, "/proc", 5);
-                        else
-                                pos = ERR_PTR(-ENOMEM);
+                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);
+                        /*
+                         * Fall back to local name if absolute name is not
+                         * available.
+                         */
+                        if (pos == ERR_PTR(-EINVAL))
+                                pos = tomoyo_get_local_path(path->dentry, buf,
+                                                            buf_len - 1);
                 }
+encode:
                 if (IS_ERR(pos))
                         continue;
                 name = tomoyo_encode(pos);
@@ -147,16 +294,6 @@ char *tomoyo_realpath_from_path(struct path *path)
         kfree(buf);
         if (!name)
                 tomoyo_warn_oom(__func__);
-        else if (is_dir && *name) {
-                /* Append trailing '/' if dentry is a directory. */
-                char *pos = name + strlen(name) - 1;
-                if (*pos != '/')
-                        /*
-                         * This is OK because tomoyo_encode() reserves space
-                         * for appending "/".
-                         */
-                        *++pos = '/';
-        }
         return name;
 }
 
diff --git a/security/tomoyo/securityfs_if.c b/security/tomoyo/securityfs_if.c
index e43d5554b50..a49c3bfd4dd 100644
--- a/security/tomoyo/securityfs_if.c
+++ b/security/tomoyo/securityfs_if.c
@@ -1,9 +1,7 @@
 /*
- * security/tomoyo/common.c
+ * security/tomoyo/securityfs_if.c
  *
- * Securityfs interface for TOMOYO.
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
  */
 
 #include <linux/security.h>
@@ -34,11 +32,11 @@ static int tomoyo_open(struct inode *inode, struct file *file)
  */
 static int tomoyo_release(struct inode *inode, struct file *file)
 {
-        return tomoyo_close_control(file);
+        return tomoyo_close_control(file->private_data);
 }
 
 /**
- * tomoyo_poll - poll() for /proc/ccs/ interface.
+ * tomoyo_poll - poll() for /sys/kernel/security/tomoyo/ interface.
  *
  * @file: Pointer to "struct file".
  * @wait: Pointer to "poll_table".
@@ -63,7 +61,7 @@ static unsigned int tomoyo_poll(struct file *file, poll_table *wait)
 static ssize_t tomoyo_read(struct file *file, char __user *buf, size_t count,
                            loff_t *ppos)
 {
-        return tomoyo_read_control(file, buf, count);
+        return tomoyo_read_control(file->private_data, buf, count);
 }
 
 /**
@@ -79,7 +77,7 @@ static ssize_t tomoyo_read(struct file *file, char __user *buf, size_t count,
 static ssize_t tomoyo_write(struct file *file, const char __user *buf,
                             size_t count, loff_t *ppos)
 {
-        return tomoyo_write_control(file, buf, count);
+        return tomoyo_write_control(file->private_data, buf, count);
 }
 
 /*
@@ -135,14 +133,14 @@ static int __init tomoyo_initerface_init(void)
                             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(".domain_status",   0600, tomoyo_dir,
-                            TOMOYO_DOMAIN_STATUS);
         tomoyo_create_entry(".process_status",  0600, tomoyo_dir,
                             TOMOYO_PROCESS_STATUS);
-        tomoyo_create_entry("meminfo",          0600, tomoyo_dir,
-                            TOMOYO_MEMINFO);
+        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,
diff --git a/security/tomoyo/tomoyo.c b/security/tomoyo/tomoyo.c
index 95d3f957223..f776400a8f3 100644
--- a/security/tomoyo/tomoyo.c
+++ b/security/tomoyo/tomoyo.c
@@ -1,20 +1,35 @@
 /*
  * security/tomoyo/tomoyo.c
  *
- * LSM hooks for TOMOYO Linux.
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
+ * Copyright (C) 2005-2011  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)
 {
@@ -25,11 +40,22 @@ static int tomoyo_cred_prepare(struct cred *new, const struct cred *old,
         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;
@@ -37,6 +63,13 @@ static void tomoyo_cred_free(struct cred *cred)
                 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;
@@ -51,12 +84,14 @@ static int tomoyo_bprm_set_creds(struct linux_binprm *bprm)
          */
         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"
@@ -73,6 +108,13 @@ static int tomoyo_bprm_set_creds(struct linux_binprm *bprm)
         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;
@@ -90,20 +132,59 @@ static int tomoyo_bprm_check_security(struct linux_binprm *bprm)
         /*
          * 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);
+        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);
+        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)
 {
@@ -112,19 +193,46 @@ static int tomoyo_path_mkdir(struct path *parent, struct dentry *dentry,
                                        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);
+        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);
+        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)
 {
@@ -155,6 +263,15 @@ static int tomoyo_path_mknod(struct path *parent, struct dentry *dentry,
         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)
 {
@@ -163,6 +280,16 @@ static int tomoyo_path_link(struct dentry *old_dentry, struct path *new_dir,
         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,
@@ -173,14 +300,32 @@ static int tomoyo_path_rename(struct path *old_parent,
         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 tomoyo_path_perm(TOMOYO_TYPE_REWRITE, &file->f_path);
-        return 0;
+        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;
@@ -190,12 +335,30 @@ static int tomoyo_dentry_open(struct file *f, const struct cred *cred)
         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)
 {
@@ -204,6 +367,15 @@ static int tomoyo_path_chmod(struct dentry *dentry, struct vfsmount *mnt,
                                        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;
@@ -214,23 +386,57 @@ static int tomoyo_path_chown(struct path *path, uid_t uid, gid_t 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);
+        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);
+        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);
@@ -258,6 +464,7 @@ static struct security_operations tomoyo_security_ops = {
         .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,
@@ -270,6 +477,11 @@ static struct security_operations tomoyo_security_ops = {
 /* 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();
diff --git a/security/tomoyo/util.c b/security/tomoyo/util.c
index 6d5393204d9..c36bd1107fc 100644
--- a/security/tomoyo/util.c
+++ b/security/tomoyo/util.c
@@ -1,9 +1,7 @@
 /*
  * security/tomoyo/util.c
  *
- * Utility functions for TOMOYO.
- *
- * Copyright (C) 2005-2010  NTT DATA CORPORATION
+ * Copyright (C) 2005-2011  NTT DATA CORPORATION
  */
 
 #include <linux/slab.h>
@@ -15,18 +13,130 @@ 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 value type on success, 0 otherwise.
+ * Returns one of values in "enum tomoyo_value_type".
  *
  * The @src is updated to point the first character after the value
  * on success.
  */
-static u8 tomoyo_parse_ulong(unsigned long *result, char **str)
+u8 tomoyo_parse_ulong(unsigned long *result, char **str)
 {
         const char *cp = *str;
         char *ep;
@@ -43,7 +153,7 @@ static u8 tomoyo_parse_ulong(unsigned long *result, char **str)
         }
         *result = simple_strtoul(cp, &ep, base);
         if (cp == ep)
-                return 0;
+                return TOMOYO_VALUE_TYPE_INVALID;
         *str = ep;
         switch (base) {
         case 16:
@@ -81,63 +191,65 @@ void tomoyo_print_ulong(char *buffer, const int buffer_len,
 /**
  * tomoyo_parse_name_union - Parse a tomoyo_name_union.
  *
- * @filename: Name or name group.
- * @ptr:      Pointer to "struct 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(const char *filename,
+bool tomoyo_parse_name_union(struct tomoyo_acl_param *param,
                              struct tomoyo_name_union *ptr)
 {
-        if (!tomoyo_correct_word(filename))
-                return false;
-        if (filename[0] == '@') {
-                ptr->group = tomoyo_get_group(filename + 1, TOMOYO_PATH_GROUP);
-                ptr->is_group = true;
+        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);
-        ptr->is_group = false;
         return ptr->filename != NULL;
 }
 
 /**
  * tomoyo_parse_number_union - Parse a tomoyo_number_union.
  *
- * @data: Number or number range or number group.
- * @ptr:  Pointer to "struct 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(char *data, struct tomoyo_number_union *num)
+bool tomoyo_parse_number_union(struct tomoyo_acl_param *param,
+                               struct tomoyo_number_union *ptr)
 {
+        char *data;
         u8 type;
         unsigned long v;
-        memset(num, 0, sizeof(*num));
-        if (data[0] == '@') {
-                if (!tomoyo_correct_word(data))
-                        return false;
-                num->group = tomoyo_get_group(data + 1, TOMOYO_NUMBER_GROUP);
-                num->is_group = true;
-                return num->group != NULL;
+        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)
+        if (type == TOMOYO_VALUE_TYPE_INVALID)
                 return false;
-        num->values[0] = v;
-        num->min_type = type;
+        ptr->values[0] = v;
+        ptr->value_type[0] = type;
         if (!*data) {
-                num->values[1] = v;
-                num->max_type = type;
+                ptr->values[1] = v;
+                ptr->value_type[1] = type;
                 return true;
         }
         if (*data++ != '-')
                 return false;
         type = tomoyo_parse_ulong(&v, &data);
-        if (!type || *data)
+        if (type == TOMOYO_VALUE_TYPE_INVALID || *data || ptr->values[0] > v)
                 return false;
-        num->values[1] = v;
-        num->max_type = type;
+        ptr->values[1] = v;
+        ptr->value_type[1] = type;
         return true;
 }
 
@@ -185,6 +297,30 @@ static inline u8 tomoyo_make_byte(const u8 c1, const u8 c2, const u8 c3)
 }
 
 /**
+ * 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.
@@ -238,36 +374,9 @@ void tomoyo_normalize_line(unsigned char *buffer)
 }
 
 /**
- * tomoyo_tokenize - Tokenize string.
- *
- * @buffer: The line to tokenize.
- * @w:      Pointer to "char *".
- * @size:   Sizeof @w .
- *
- * Returns true on success, false otherwise.
- */
-bool tomoyo_tokenize(char *buffer, char *w[], size_t size)
-{
-        int count = size / sizeof(char *);
-        int i;
-        for (i = 0; i < count; i++)
-                w[i] = "";
-        for (i = 0; i < count; i++) {
-                char *cp = strchr(buffer, ' ');
-                if (cp)
-                        *cp = '\0';
-                w[i] = buffer;
-                if (!cp)
-                        break;
-                buffer = cp + 1;
-        }
-        return i < count || !*buffer;
-}
-
-/**
  * 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.
@@ -377,26 +486,21 @@ bool tomoyo_correct_path(const char *filename)
  */
 bool tomoyo_correct_domain(const unsigned char *domainname)
 {
-        if (!domainname || strncmp(domainname, TOMOYO_ROOT_NAME,
-                                   TOMOYO_ROOT_NAME_LEN))
-                goto out;
-        domainname += TOMOYO_ROOT_NAME_LEN;
-        if (!*domainname)
+        if (!domainname || !tomoyo_domain_def(domainname))
+                return false;
+        domainname = strchr(domainname, ' ');
+        if (!domainname++)
                 return true;
-        if (*domainname++ != ' ')
-                goto out;
         while (1) {
                 const unsigned char *cp = strchr(domainname, ' ');
                 if (!cp)
                         break;
                 if (*domainname != '/' ||
                     !tomoyo_correct_word2(domainname, cp - domainname))
-                        goto out;
+                        return false;
                 domainname = cp + 1;
         }
         return tomoyo_correct_path(domainname);
- out:
-        return false;
 }
 
 /**
@@ -408,7 +512,19 @@ bool tomoyo_correct_domain(const unsigned char *domainname)
  */
 bool tomoyo_domain_def(const unsigned char *buffer)
 {
-        return !strncmp(buffer, TOMOYO_ROOT_NAME, TOMOYO_ROOT_NAME_LEN);
+        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;
 }
 
 /**
@@ -794,22 +910,24 @@ const char *tomoyo_get_exe(void)
 /**
  * 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 u8 profile, const u8 index)
+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(profile)->config[index];
+        mode = tomoyo_profile(ns, profile)->config[index];
         if (mode == TOMOYO_CONFIG_USE_DEFAULT)
-                mode = tomoyo_profile(profile)->config[category];
+                mode = tomoyo_profile(ns, profile)->config[category];
         if (mode == TOMOYO_CONFIG_USE_DEFAULT)
-                mode = tomoyo_profile(profile)->default_config;
+                mode = tomoyo_profile(ns, profile)->default_config;
         return mode & 3;
 }
 
@@ -833,65 +951,11 @@ int tomoyo_init_request_info(struct tomoyo_request_info *r,
         profile = domain->profile;
         r->profile = profile;
         r->type = index;
-        r->mode = tomoyo_get_mode(profile, index);
+        r->mode = tomoyo_get_mode(domain->ns, profile, index);
         return r->mode;
 }
 
 /**
- * tomoyo_last_word - Get last component of a line.
- *
- * @line: A line.
- *
- * Returns the last word of a line.
- */
-const char *tomoyo_last_word(const char *name)
-{
-        const char *cp = strrchr(name, ' ');
-        if (cp)
-                return cp + 1;
-        return name;
-}
-
-/**
- * tomoyo_warn_log - Print warning or error message on console.
- *
- * @r:   Pointer to "struct tomoyo_request_info".
- * @fmt: The printf()'s format string, followed by parameters.
- */
-void tomoyo_warn_log(struct tomoyo_request_info *r, const char *fmt, ...)
-{
-        va_list args;
-        char *buffer;
-        const struct tomoyo_domain_info * const domain = r->domain;
-        const struct tomoyo_profile *profile = tomoyo_profile(domain->profile);
-        switch (r->mode) {
-        case TOMOYO_CONFIG_ENFORCING:
-                if (!profile->enforcing->enforcing_verbose)
-                        return;
-                break;
-        case TOMOYO_CONFIG_PERMISSIVE:
-                if (!profile->permissive->permissive_verbose)
-                        return;
-                break;
-        case TOMOYO_CONFIG_LEARNING:
-                if (!profile->learning->learning_verbose)
-                        return;
-                break;
-        }
-        buffer = kmalloc(4096, GFP_NOFS);
-        if (!buffer)
-                return;
-        va_start(args, fmt);
-        vsnprintf(buffer, 4095, fmt, args);
-        va_end(args);
-        buffer[4095] = '\0';
-        printk(KERN_WARNING "%s: Access %s denied for %s\n",
-               r->mode == TOMOYO_CONFIG_ENFORCING ? "ERROR" : "WARNING", buffer,
-               tomoyo_last_word(domain->domainname->name));
-        kfree(buffer);
-}
-
-/**
  * tomoyo_domain_quota_is_ok - Check for domain's quota.
  *
  * @r: Pointer to "struct tomoyo_request_info".
@@ -911,52 +975,43 @@ bool tomoyo_domain_quota_is_ok(struct tomoyo_request_info *r)
         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) {
-                        u16 perm;
-                        u8 i;
                 case TOMOYO_TYPE_PATH_ACL:
                         perm = container_of(ptr, struct tomoyo_path_acl, head)
                                 ->perm;
-                        for (i = 0; i < TOMOYO_MAX_PATH_OPERATION; i++)
-                                if (perm & (1 << i))
-                                        count++;
-                        if (perm & (1 << TOMOYO_TYPE_READ_WRITE))
-                                count -= 2;
                         break;
                 case TOMOYO_TYPE_PATH2_ACL:
                         perm = container_of(ptr, struct tomoyo_path2_acl, head)
                                 ->perm;
-                        for (i = 0; i < TOMOYO_MAX_PATH2_OPERATION; i++)
-                                if (perm & (1 << i))
-                                        count++;
                         break;
                 case TOMOYO_TYPE_PATH_NUMBER_ACL:
                         perm = container_of(ptr, struct tomoyo_path_number_acl,
                                             head)->perm;
-                        for (i = 0; i < TOMOYO_MAX_PATH_NUMBER_OPERATION; i++)
-                                if (perm & (1 << i))
-                                        count++;
                         break;
                 case TOMOYO_TYPE_MKDEV_ACL:
                         perm = container_of(ptr, struct tomoyo_mkdev_acl,
                                             head)->perm;
-                        for (i = 0; i < TOMOYO_MAX_MKDEV_OPERATION; i++)
-                                if (perm & (1 << i))
-                                        count++;
                         break;
                 default:
-                        count++;
+                        perm = 1;
                 }
+                for (i = 0; i < 16; i++)
+                        if (perm & (1 << i))
+                                count++;
         }
-        if (count < tomoyo_profile(domain->profile)->learning->
-            learning_max_entry)
+        if (count < tomoyo_profile(domain->ns, domain->profile)->
+            pref[TOMOYO_PREF_MAX_LEARNING_ENTRY])
                 return true;
-        if (!domain->quota_warned) {
-                domain->quota_warned = true;
-                printk(KERN_WARNING "TOMOYO-WARNING: "
-                       "Domain '%s' has so many ACLs to hold. "
+        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;