]> bbs.cooldavid.org Git - net-next-2.6.git/blobdiff - security/tomoyo/file.c
TOMOYO: Aggregate reader functions.
[net-next-2.6.git] / security / tomoyo / file.c
index 50875d7e8603375d9d5774e4abbde1d7a5bcba5b..e7687ebdc5f6af8b6f820690e2b1577175ec9efb 100644 (file)
@@ -10,7 +10,7 @@
 #include <linux/slab.h>
 
 /* Keyword array for operations with one pathname. */
-static const char *tomoyo_path_keyword[TOMOYO_MAX_PATH_OPERATION] = {
+const char *tomoyo_path_keyword[TOMOYO_MAX_PATH_OPERATION] = {
        [TOMOYO_TYPE_READ_WRITE] = "read/write",
        [TOMOYO_TYPE_EXECUTE]    = "execute",
        [TOMOYO_TYPE_READ]       = "read",
@@ -25,22 +25,20 @@ static const char *tomoyo_path_keyword[TOMOYO_MAX_PATH_OPERATION] = {
 };
 
 /* Keyword array for operations with one pathname and three numbers. */
-static const char *tomoyo_path_number3_keyword
-[TOMOYO_MAX_PATH_NUMBER3_OPERATION] = {
+const char *tomoyo_mkdev_keyword[TOMOYO_MAX_MKDEV_OPERATION] = {
        [TOMOYO_TYPE_MKBLOCK]    = "mkblock",
        [TOMOYO_TYPE_MKCHAR]     = "mkchar",
 };
 
 /* Keyword array for operations with two pathnames. */
-static const char *tomoyo_path2_keyword[TOMOYO_MAX_PATH2_OPERATION] = {
+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. */
-static const char *tomoyo_path_number_keyword
-[TOMOYO_MAX_PATH_NUMBER_OPERATION] = {
+const char *tomoyo_path_number_keyword[TOMOYO_MAX_PATH_NUMBER_OPERATION] = {
        [TOMOYO_TYPE_CREATE]     = "create",
        [TOMOYO_TYPE_MKDIR]      = "mkdir",
        [TOMOYO_TYPE_MKFIFO]     = "mkfifo",
@@ -65,7 +63,7 @@ static const u8 tomoyo_p2mac[TOMOYO_MAX_PATH_OPERATION] = {
        [TOMOYO_TYPE_UMOUNT]     = TOMOYO_MAC_FILE_UMOUNT,
 };
 
-static const u8 tomoyo_pnnn2mac[TOMOYO_MAX_PATH_NUMBER3_OPERATION] = {
+static const u8 tomoyo_pnnn2mac[TOMOYO_MAX_MKDEV_OPERATION] = {
        [TOMOYO_TYPE_MKBLOCK] = TOMOYO_MAC_FILE_MKBLOCK,
        [TOMOYO_TYPE_MKCHAR]  = TOMOYO_MAC_FILE_MKCHAR,
 };
@@ -92,7 +90,7 @@ void tomoyo_put_name_union(struct tomoyo_name_union *ptr)
        if (!ptr)
                return;
        if (ptr->is_group)
-               tomoyo_put_path_group(ptr->group);
+               tomoyo_put_group(ptr->group);
        else
                tomoyo_put_name(ptr->filename);
 }
@@ -108,7 +106,7 @@ bool tomoyo_compare_name_union(const struct tomoyo_path_info *name,
 void tomoyo_put_number_union(struct tomoyo_number_union *ptr)
 {
        if (ptr && ptr->is_group)
-               tomoyo_put_number_group(ptr->group);
+               tomoyo_put_group(ptr->group);
 }
 
 bool tomoyo_compare_number_union(const unsigned long value,
@@ -119,58 +117,6 @@ bool tomoyo_compare_number_union(const unsigned long value,
        return value >= ptr->values[0] && value <= ptr->values[1];
 }
 
-/**
- * tomoyo_path2keyword - Get the name of single path operation.
- *
- * @operation: Type of operation.
- *
- * Returns the name of single path operation.
- */
-const char *tomoyo_path2keyword(const u8 operation)
-{
-       return (operation < TOMOYO_MAX_PATH_OPERATION)
-               ? tomoyo_path_keyword[operation] : NULL;
-}
-
-/**
- * tomoyo_path_number32keyword - Get the name of path/number/number/number operations.
- *
- * @operation: Type of operation.
- *
- * Returns the name of path/number/number/number operation.
- */
-const char *tomoyo_path_number32keyword(const u8 operation)
-{
-       return (operation < TOMOYO_MAX_PATH_NUMBER3_OPERATION)
-               ? tomoyo_path_number3_keyword[operation] : NULL;
-}
-
-/**
- * tomoyo_path22keyword - Get the name of double path operation.
- *
- * @operation: Type of operation.
- *
- * Returns the name of double path operation.
- */
-const char *tomoyo_path22keyword(const u8 operation)
-{
-       return (operation < TOMOYO_MAX_PATH2_OPERATION)
-               ? tomoyo_path2_keyword[operation] : NULL;
-}
-
-/**
- * tomoyo_path_number2keyword - Get the name of path/number operations.
- *
- * @operation: Type of operation.
- *
- * Returns the name of path/number operation.
- */
-const char *tomoyo_path_number2keyword(const u8 operation)
-{
-       return (operation < TOMOYO_MAX_PATH_NUMBER_OPERATION)
-               ? tomoyo_path_number_keyword[operation] : NULL;
-}
-
 static void tomoyo_add_slash(struct tomoyo_path_info *buf)
 {
        if (buf->is_dir)
@@ -218,40 +164,106 @@ static bool tomoyo_get_realpath(struct tomoyo_path_info *buf, struct path *path)
         return false;
 }
 
-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_path_acl(const u8 type, const char *filename,
-                                 struct tomoyo_domain_info *const domain,
-                                 const bool is_delete);
-
-/*
- * tomoyo_globally_readable_list is used for holding list of pathnames which
- * are by default allowed to be open()ed for reading by any process.
+/**
+ * tomoyo_audit_path_log - Audit path request log.
  *
- * An entry is added by
+ * @r: Pointer to "struct tomoyo_request_info".
  *
- * # echo 'allow_read /lib/libc-2.5.so' > \
- *                               /sys/kernel/security/tomoyo/exception_policy
+ * Returns 0 on success, negative value otherwise.
+ */
+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_file_pattern(filename));
+}
+
+/**
+ * tomoyo_audit_path2_log - Audit path/path request log.
  *
- * and is deleted by
+ * @r: Pointer to "struct tomoyo_request_info".
  *
- * # echo 'delete allow_read /lib/libc-2.5.so' > \
- *                               /sys/kernel/security/tomoyo/exception_policy
+ * Returns 0 on success, negative value otherwise.
+ */
+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_file_pattern(filename1),
+                                tomoyo_file_pattern(filename2));
+}
+
+/**
+ * tomoyo_audit_mkdev_log - Audit path/number/number/number request log.
  *
- * and all entries are retrieved by
+ * @r: Pointer to "struct tomoyo_request_info".
  *
- * # grep ^allow_read /sys/kernel/security/tomoyo/exception_policy
+ * Returns 0 on success, negative value otherwise.
+ */
+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_file_pattern(filename), mode, major,
+                                minor);
+}
+
+/**
+ * tomoyo_audit_path_number_log - Audit path/number request log.
  *
- * In the example above, any process is allowed to
- * open("/lib/libc-2.5.so", O_RDONLY).
- * One exception is, if the domain which current process belongs to is marked
- * as "ignore_global_allow_read", current process can't do so unless explicitly
- * given "allow_read /lib/libc-2.5.so" to the domain which current process
- * belongs to.
+ * @r:     Pointer to "struct tomoyo_request_info".
+ * @error: Error code.
+ *
+ * Returns 0 on success, negative value otherwise.
  */
-LIST_HEAD(tomoyo_globally_readable_list);
+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:
+       case TOMOYO_TYPE_MKFIFO:
+       case TOMOYO_TYPE_MKSOCK:
+       case TOMOYO_TYPE_CHMOD:
+               radix = TOMOYO_VALUE_TYPE_OCTAL;
+               break;
+       case TOMOYO_TYPE_IOCTL:
+               radix = TOMOYO_VALUE_TYPE_HEXADECIMAL;
+               break;
+       default:
+               radix = TOMOYO_VALUE_TYPE_DECIMAL;
+               break;
+       }
+       tomoyo_print_ulong(buffer, sizeof(buffer), r->param.path_number.number,
+                          radix);
+       tomoyo_warn_log(r, "%s %s %s", operation, filename->name, buffer);
+       return tomoyo_supervisor(r, "allow_%s %s %s\n", operation,
+                                tomoyo_file_pattern(filename), buffer);
+}
 
 static bool tomoyo_same_globally_readable(const struct tomoyo_acl_head *a,
                                          const struct tomoyo_acl_head *b)
@@ -278,20 +290,21 @@ static int tomoyo_update_globally_readable_entry(const char *filename,
        struct tomoyo_globally_readable_file_entry e = { };
        int error;
 
-       if (!tomoyo_is_correct_word(filename))
+       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_globally_readable_list,
+                                    &tomoyo_policy_list
+                                    [TOMOYO_ID_GLOBALLY_READABLE],
                                     tomoyo_same_globally_readable);
        tomoyo_put_name(e.filename);
        return error;
 }
 
 /**
- * tomoyo_is_globally_readable_file - Check if the file is unconditionnaly permitted to be open()ed for reading.
+ * tomoyo_globally_readable_file - Check if the file is unconditionnaly permitted to be open()ed for reading.
  *
  * @filename: The filename to check.
  *
@@ -299,14 +312,14 @@ static int tomoyo_update_globally_readable_entry(const char *filename,
  *
  * Caller holds tomoyo_read_lock().
  */
-static bool tomoyo_is_globally_readable_file(const struct tomoyo_path_info *
+static bool tomoyo_globally_readable_file(const struct tomoyo_path_info *
                                             filename)
 {
        struct tomoyo_globally_readable_file_entry *ptr;
        bool found = false;
 
-       list_for_each_entry_rcu(ptr, &tomoyo_globally_readable_list,
-                               head.list) {
+       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;
@@ -331,67 +344,6 @@ int tomoyo_write_globally_readable_policy(char *data, const bool is_delete)
        return tomoyo_update_globally_readable_entry(data, is_delete);
 }
 
-/**
- * tomoyo_read_globally_readable_policy - Read "struct tomoyo_globally_readable_file_entry" list.
- *
- * @head: Pointer to "struct tomoyo_io_buffer".
- *
- * Returns true on success, false otherwise.
- *
- * Caller holds tomoyo_read_lock().
- */
-bool tomoyo_read_globally_readable_policy(struct tomoyo_io_buffer *head)
-{
-       struct list_head *pos;
-       bool done = true;
-
-       list_for_each_cookie(pos, head->read_var2,
-                            &tomoyo_globally_readable_list) {
-               struct tomoyo_globally_readable_file_entry *ptr;
-               ptr = list_entry(pos,
-                                struct tomoyo_globally_readable_file_entry,
-                                head.list);
-               if (ptr->head.is_deleted)
-                       continue;
-               done = tomoyo_io_printf(head, TOMOYO_KEYWORD_ALLOW_READ "%s\n",
-                                       ptr->filename->name);
-               if (!done)
-                       break;
-       }
-       return done;
-}
-
-/* tomoyo_pattern_list is used for holding list of pathnames which are used for
- * converting pathnames to pathname patterns during learning mode.
- *
- * An entry is added by
- *
- * # echo 'file_pattern /proc/\$/mounts' > \
- *                             /sys/kernel/security/tomoyo/exception_policy
- *
- * and is deleted by
- *
- * # echo 'delete file_pattern /proc/\$/mounts' > \
- *                             /sys/kernel/security/tomoyo/exception_policy
- *
- * and all entries are retrieved by
- *
- * # grep ^file_pattern /sys/kernel/security/tomoyo/exception_policy
- *
- * In the example above, if a process which belongs to a domain which is in
- * learning mode requested open("/proc/1/mounts", O_RDONLY),
- * "allow_read /proc/\$/mounts" is automatically added to the domain which that
- * process belongs to.
- *
- * It is not a desirable behavior that we have to use /proc/\$/ instead of
- * /proc/self/ when current process needs to access only current process's
- * information. As of now, LSM version of TOMOYO is using __d_path() for
- * calculating pathname. Non LSM version of TOMOYO is using its own function
- * which pretends as if /proc/self/ is not a symlink; so that we can forbid
- * current process from accessing other process's information.
- */
-LIST_HEAD(tomoyo_pattern_list);
-
 static bool tomoyo_same_pattern(const struct tomoyo_acl_head *a,
                                const struct tomoyo_acl_head *b)
 {
@@ -415,13 +367,13 @@ static int tomoyo_update_file_pattern_entry(const char *pattern,
        struct tomoyo_pattern_entry e = { };
        int error;
 
-       if (!tomoyo_is_correct_word(pattern))
+       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_pattern_list,
+                                    &tomoyo_policy_list[TOMOYO_ID_PATTERN],
                                     tomoyo_same_pattern);
        tomoyo_put_name(e.pattern);
        return error;
@@ -441,7 +393,8 @@ const char *tomoyo_file_pattern(const struct tomoyo_path_info *filename)
        struct tomoyo_pattern_entry *ptr;
        const struct tomoyo_path_info *pattern = NULL;
 
-       list_for_each_entry_rcu(ptr, &tomoyo_pattern_list, head.list) {
+       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))
@@ -474,64 +427,6 @@ int tomoyo_write_pattern_policy(char *data, const bool is_delete)
        return tomoyo_update_file_pattern_entry(data, is_delete);
 }
 
-/**
- * tomoyo_read_file_pattern - Read "struct tomoyo_pattern_entry" list.
- *
- * @head: Pointer to "struct tomoyo_io_buffer".
- *
- * Returns true on success, false otherwise.
- *
- * Caller holds tomoyo_read_lock().
- */
-bool tomoyo_read_file_pattern(struct tomoyo_io_buffer *head)
-{
-       struct list_head *pos;
-       bool done = true;
-
-       list_for_each_cookie(pos, head->read_var2, &tomoyo_pattern_list) {
-               struct tomoyo_pattern_entry *ptr;
-               ptr = list_entry(pos, struct tomoyo_pattern_entry, head.list);
-               if (ptr->head.is_deleted)
-                       continue;
-               done = tomoyo_io_printf(head, TOMOYO_KEYWORD_FILE_PATTERN
-                                       "%s\n", ptr->pattern->name);
-               if (!done)
-                       break;
-       }
-       return done;
-}
-
-/*
- * tomoyo_no_rewrite_list is used for holding list of pathnames which are by
- * default forbidden to modify already written content of a file.
- *
- * An entry is added by
- *
- * # echo 'deny_rewrite /var/log/messages' > \
- *                              /sys/kernel/security/tomoyo/exception_policy
- *
- * and is deleted by
- *
- * # echo 'delete deny_rewrite /var/log/messages' > \
- *                              /sys/kernel/security/tomoyo/exception_policy
- *
- * and all entries are retrieved by
- *
- * # grep ^deny_rewrite /sys/kernel/security/tomoyo/exception_policy
- *
- * In the example above, if a process requested to rewrite /var/log/messages ,
- * the process can't rewrite unless the domain which that process belongs to
- * has "allow_rewrite /var/log/messages" entry.
- *
- * It is not a desirable behavior that we have to add "\040(deleted)" suffix
- * when we want to allow rewriting already unlink()ed file. As of now,
- * LSM version of TOMOYO is using __d_path() for calculating pathname.
- * Non LSM version of TOMOYO is using its own function which doesn't append
- * " (deleted)" suffix if the file is already unlink()ed; so that we don't
- * need to worry whether the file is already unlink()ed or not.
- */
-LIST_HEAD(tomoyo_no_rewrite_list);
-
 static bool tomoyo_same_no_rewrite(const struct tomoyo_acl_head *a,
                                   const struct tomoyo_acl_head *b)
 {
@@ -556,20 +451,20 @@ static int tomoyo_update_no_rewrite_entry(const char *pattern,
        struct tomoyo_no_rewrite_entry e = { };
        int error;
 
-       if (!tomoyo_is_correct_word(pattern))
+       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_no_rewrite_list,
+                                    &tomoyo_policy_list[TOMOYO_ID_NO_REWRITE],
                                     tomoyo_same_no_rewrite);
        tomoyo_put_name(e.pattern);
        return error;
 }
 
 /**
- * tomoyo_is_no_rewrite_file - Check if the given pathname is not permitted to be rewrited.
+ * tomoyo_no_rewrite_file - Check if the given pathname is not permitted to be rewrited.
  *
  * @filename: Filename to check.
  *
@@ -578,12 +473,13 @@ static int tomoyo_update_no_rewrite_entry(const char *pattern,
  *
  * Caller holds tomoyo_read_lock().
  */
-static bool tomoyo_is_no_rewrite_file(const struct tomoyo_path_info *filename)
+static bool tomoyo_no_rewrite_file(const struct tomoyo_path_info *filename)
 {
        struct tomoyo_no_rewrite_entry *ptr;
        bool found = false;
 
-       list_for_each_entry_rcu(ptr, &tomoyo_no_rewrite_list, head.list) {
+       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))
@@ -609,65 +505,52 @@ int tomoyo_write_no_rewrite_policy(char *data, const bool is_delete)
        return tomoyo_update_no_rewrite_entry(data, is_delete);
 }
 
-/**
- * tomoyo_read_no_rewrite_policy - Read "struct tomoyo_no_rewrite_entry" list.
- *
- * @head: Pointer to "struct tomoyo_io_buffer".
- *
- * Returns true on success, false otherwise.
- *
- * Caller holds tomoyo_read_lock().
- */
-bool tomoyo_read_no_rewrite_policy(struct tomoyo_io_buffer *head)
+static bool tomoyo_check_path_acl(const struct tomoyo_request_info *r,
+                                 const struct tomoyo_acl_info *ptr)
 {
-       struct list_head *pos;
-       bool done = true;
+       const struct tomoyo_path_acl *acl = container_of(ptr, typeof(*acl),
+                                                        head);
+       return (acl->perm & (1 << r->param.path.operation)) &&
+               tomoyo_compare_name_union(r->param.path.filename, &acl->name);
+}
 
-       list_for_each_cookie(pos, head->read_var2, &tomoyo_no_rewrite_list) {
-               struct tomoyo_no_rewrite_entry *ptr;
-               ptr = list_entry(pos, struct tomoyo_no_rewrite_entry,
-                                head.list);
-               if (ptr->head.is_deleted)
-                       continue;
-               done = tomoyo_io_printf(head, TOMOYO_KEYWORD_DENY_REWRITE
-                                       "%s\n", ptr->pattern->name);
-               if (!done)
-                       break;
-       }
-       return done;
+static bool tomoyo_check_path_number_acl(const struct tomoyo_request_info *r,
+                                        const struct tomoyo_acl_info *ptr)
+{
+       const struct tomoyo_path_number_acl *acl =
+               container_of(ptr, typeof(*acl), head);
+       return (acl->perm & (1 << r->param.path_number.operation)) &&
+               tomoyo_compare_number_union(r->param.path_number.number,
+                                           &acl->number) &&
+               tomoyo_compare_name_union(r->param.path_number.filename,
+                                         &acl->name);
 }
 
-/**
- * tomoyo_path_acl - Check permission for single path operation.
- *
- * @r:               Pointer to "struct tomoyo_request_info".
- * @filename:        Filename to check.
- * @perm:            Permission.
- *
- * Returns 0 on success, -EPERM otherwise.
- *
- * Caller holds tomoyo_read_lock().
- */
-static int tomoyo_path_acl(const struct tomoyo_request_info *r,
-                          const struct tomoyo_path_info *filename,
-                          const u32 perm)
+static bool tomoyo_check_path2_acl(const struct tomoyo_request_info *r,
+                                  const struct tomoyo_acl_info *ptr)
 {
-       struct tomoyo_domain_info *domain = r->domain;
-       struct tomoyo_acl_info *ptr;
-       int error = -EPERM;
+       const struct tomoyo_path2_acl *acl =
+               container_of(ptr, typeof(*acl), head);
+       return (acl->perm & (1 << r->param.path2.operation)) &&
+               tomoyo_compare_name_union(r->param.path2.filename1, &acl->name1)
+               && tomoyo_compare_name_union(r->param.path2.filename2,
+                                            &acl->name2);
+}
 
-       list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
-               struct tomoyo_path_acl *acl;
-               if (ptr->type != TOMOYO_TYPE_PATH_ACL)
-                       continue;
-               acl = container_of(ptr, struct tomoyo_path_acl, head);
-               if (!(acl->perm & perm) ||
-                   !tomoyo_compare_name_union(filename, &acl->name))
-                       continue;
-               error = 0;
-               break;
-       }
-       return error;
+static bool tomoyo_check_mkdev_acl(const struct tomoyo_request_info *r,
+                               const struct tomoyo_acl_info *ptr)
+{
+       const struct tomoyo_mkdev_acl *acl =
+               container_of(ptr, typeof(*acl), head);
+       return (acl->perm & (1 << r->param.mkdev.operation)) &&
+               tomoyo_compare_number_union(r->param.mkdev.mode,
+                                           &acl->mode) &&
+               tomoyo_compare_number_union(r->param.mkdev.major,
+                                           &acl->major) &&
+               tomoyo_compare_number_union(r->param.mkdev.minor,
+                                           &acl->minor) &&
+               tomoyo_compare_name_union(r->param.mkdev.filename,
+                                         &acl->name);
 }
 
 static bool tomoyo_same_path_acl(const struct tomoyo_acl_info *a,
@@ -675,8 +558,8 @@ static bool tomoyo_same_path_acl(const struct tomoyo_acl_info *a,
 {
        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_is_same_acl_head(&p1->head, &p2->head) &&
-               tomoyo_is_same_name_union(&p1->name, &p2->name);
+       return tomoyo_same_acl_head(&p1->head, &p2->head) &&
+               tomoyo_same_name_union(&p1->name, &p2->name);
 }
 
 static bool tomoyo_merge_path_acl(struct tomoyo_acl_info *a,
@@ -736,28 +619,28 @@ static int tomoyo_update_path_acl(const u8 type, const char *filename,
        return error;
 }
 
-static bool tomoyo_same_path_number3_acl(const struct tomoyo_acl_info *a,
+static bool tomoyo_same_mkdev_acl(const struct tomoyo_acl_info *a,
                                         const struct tomoyo_acl_info *b)
 {
-       const struct tomoyo_path_number3_acl *p1 = container_of(a, typeof(*p1),
+       const struct tomoyo_mkdev_acl *p1 = container_of(a, typeof(*p1),
                                                                head);
-       const struct tomoyo_path_number3_acl *p2 = container_of(b, typeof(*p2),
+       const struct tomoyo_mkdev_acl *p2 = container_of(b, typeof(*p2),
                                                                head);
-       return tomoyo_is_same_acl_head(&p1->head, &p2->head)
-               && tomoyo_is_same_name_union(&p1->name, &p2->name)
-               && tomoyo_is_same_number_union(&p1->mode, &p2->mode)
-               && tomoyo_is_same_number_union(&p1->major, &p2->major)
-               && tomoyo_is_same_number_union(&p1->minor, &p2->minor);
+       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);
 }
 
-static bool tomoyo_merge_path_number3_acl(struct tomoyo_acl_info *a,
+static bool tomoyo_merge_mkdev_acl(struct tomoyo_acl_info *a,
                                          struct tomoyo_acl_info *b,
                                          const bool is_delete)
 {
-       u8 *const a_perm = &container_of(a, struct tomoyo_path_number3_acl,
+       u8 *const a_perm = &container_of(a, struct tomoyo_mkdev_acl,
                                         head)->perm;
        u8 perm = *a_perm;
-       const u8 b_perm = container_of(b, struct tomoyo_path_number3_acl, head)
+       const u8 b_perm = container_of(b, struct tomoyo_mkdev_acl, head)
                ->perm;
        if (is_delete)
                perm &= ~b_perm;
@@ -768,7 +651,7 @@ static bool tomoyo_merge_path_number3_acl(struct tomoyo_acl_info *a,
 }
 
 /**
- * tomoyo_update_path_number3_acl - Update "struct tomoyo_path_number3_acl" list.
+ * tomoyo_update_mkdev_acl - Update "struct tomoyo_mkdev_acl" list.
  *
  * @type:      Type of operation.
  * @filename:  Filename.
@@ -782,13 +665,13 @@ static bool tomoyo_merge_path_number3_acl(struct tomoyo_acl_info *a,
  *
  * Caller holds tomoyo_read_lock().
  */
-static int tomoyo_update_path_number3_acl(const u8 type, const char *filename,
+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)
 {
-       struct tomoyo_path_number3_acl e = {
-               .head.type = TOMOYO_TYPE_PATH_NUMBER3_ACL,
+       struct tomoyo_mkdev_acl e = {
+               .head.type = TOMOYO_TYPE_MKDEV_ACL,
                .perm = 1 << type
        };
        int error = is_delete ? -ENOENT : -ENOMEM;
@@ -798,8 +681,8 @@ static int tomoyo_update_path_number3_acl(const u8 type, const char *filename,
            !tomoyo_parse_number_union(minor, &e.minor))
                goto out;
        error = tomoyo_update_domain(&e.head, sizeof(e), is_delete, domain,
-                                    tomoyo_same_path_number3_acl,
-                                    tomoyo_merge_path_number3_acl);
+                                    tomoyo_same_mkdev_acl,
+                                    tomoyo_merge_mkdev_acl);
  out:
        tomoyo_put_name_union(&e.name);
        tomoyo_put_number_union(&e.mode);
@@ -813,9 +696,9 @@ static bool tomoyo_same_path2_acl(const struct tomoyo_acl_info *a,
 {
        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_is_same_acl_head(&p1->head, &p2->head)
-               && tomoyo_is_same_name_union(&p1->name1, &p2->name1)
-               && tomoyo_is_same_name_union(&p1->name2, &p2->name2);
+       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);
 }
 
 static bool tomoyo_merge_path2_acl(struct tomoyo_acl_info *a,
@@ -869,88 +752,6 @@ static int tomoyo_update_path2_acl(const u8 type, const char *filename1,
        return error;
 }
 
-/**
- * tomoyo_path_number3_acl - Check permission for path/number/number/number operation.
- *
- * @r:        Pointer to "struct tomoyo_request_info".
- * @filename: Filename to check.
- * @perm:     Permission.
- * @mode:     Create mode.
- * @major:    Device major number.
- * @minor:    Device minor number.
- *
- * Returns 0 on success, -EPERM otherwise.
- *
- * Caller holds tomoyo_read_lock().
- */
-static int tomoyo_path_number3_acl(struct tomoyo_request_info *r,
-                                  const struct tomoyo_path_info *filename,
-                                  const u16 perm, const unsigned int mode,
-                                  const unsigned int major,
-                                  const unsigned int minor)
-{
-       struct tomoyo_domain_info *domain = r->domain;
-       struct tomoyo_acl_info *ptr;
-       int error = -EPERM;
-       list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
-               struct tomoyo_path_number3_acl *acl;
-               if (ptr->type != TOMOYO_TYPE_PATH_NUMBER3_ACL)
-                       continue;
-               acl = container_of(ptr, struct tomoyo_path_number3_acl, head);
-               if (!tomoyo_compare_number_union(mode, &acl->mode))
-                       continue;
-               if (!tomoyo_compare_number_union(major, &acl->major))
-                       continue;
-               if (!tomoyo_compare_number_union(minor, &acl->minor))
-                       continue;
-               if (!(acl->perm & perm))
-                       continue;
-               if (!tomoyo_compare_name_union(filename, &acl->name))
-                       continue;
-               error = 0;
-               break;
-       }
-       return error;
-}
-
-/**
- * tomoyo_path2_acl - Check permission for double path operation.
- *
- * @r:         Pointer to "struct tomoyo_request_info".
- * @type:      Type of operation.
- * @filename1: First filename to check.
- * @filename2: Second filename to check.
- *
- * Returns 0 on success, -EPERM otherwise.
- *
- * Caller holds tomoyo_read_lock().
- */
-static int tomoyo_path2_acl(const struct tomoyo_request_info *r, const u8 type,
-                           const struct tomoyo_path_info *filename1,
-                           const struct tomoyo_path_info *filename2)
-{
-       const struct tomoyo_domain_info *domain = r->domain;
-       struct tomoyo_acl_info *ptr;
-       const u8 perm = 1 << type;
-       int error = -EPERM;
-
-       list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
-               struct tomoyo_path2_acl *acl;
-               if (ptr->type != TOMOYO_TYPE_PATH2_ACL)
-                       continue;
-               acl = container_of(ptr, struct tomoyo_path2_acl, head);
-               if (!(acl->perm & perm))
-                       continue;
-               if (!tomoyo_compare_name_union(filename1, &acl->name1))
-                       continue;
-               if (!tomoyo_compare_name_union(filename2, &acl->name2))
-                       continue;
-               error = 0;
-               break;
-       }
-       return error;
-}
-
 /**
  * tomoyo_path_permission - Check permission for single path operation.
  *
@@ -965,7 +766,6 @@ static int tomoyo_path2_acl(const struct tomoyo_request_info *r, const u8 type,
 int tomoyo_path_permission(struct tomoyo_request_info *r, u8 operation,
                           const struct tomoyo_path_info *filename)
 {
-       const char *msg;
        int error;
 
  next:
@@ -973,18 +773,16 @@ int tomoyo_path_permission(struct tomoyo_request_info *r, u8 operation,
        r->mode = tomoyo_get_mode(r->profile, r->type);
        if (r->mode == TOMOYO_CONFIG_DISABLED)
                return 0;
+       r->param_type = TOMOYO_TYPE_PATH_ACL;
+       r->param.path.filename = filename;
+       r->param.path.operation = operation;
        do {
-               error = tomoyo_path_acl(r, filename, 1 << operation);
-               if (error && operation == TOMOYO_TYPE_READ &&
+               tomoyo_check_acl(r, tomoyo_check_path_acl);
+               if (!r->granted && operation == TOMOYO_TYPE_READ &&
                    !r->domain->ignore_global_allow_read &&
-                   tomoyo_is_globally_readable_file(filename))
-                       error = 0;
-               if (!error)
-                       break;
-               msg = tomoyo_path2keyword(operation);
-               tomoyo_warn_log(r, "%s %s", msg, filename->name);
-               error = tomoyo_supervisor(r, "allow_%s %s\n", msg,
-                                         tomoyo_file_pattern(filename));
+                   tomoyo_globally_readable_file(filename))
+                       r->granted = true;
+               error = tomoyo_audit_path_log(r);
                /*
                 * Do not retry for execute request, for alias may have
                 * changed.
@@ -997,49 +795,13 @@ int tomoyo_path_permission(struct tomoyo_request_info *r, u8 operation,
         * specified by "deny_rewrite" keyword.
         */
        if (!error && operation == TOMOYO_TYPE_TRUNCATE &&
-           tomoyo_is_no_rewrite_file(filename)) {
+           tomoyo_no_rewrite_file(filename)) {
                operation = TOMOYO_TYPE_REWRITE;
                goto next;
        }
        return error;
 }
 
-/**
- * tomoyo_path_number_acl - Check permission for ioctl/chmod/chown/chgrp operation.
- *
- * @r:        Pointer to "struct tomoyo_request_info".
- * @type:     Operation.
- * @filename: Filename to check.
- * @number:   Number.
- *
- * Returns 0 on success, -EPERM otherwise.
- *
- * Caller holds tomoyo_read_lock().
- */
-static int tomoyo_path_number_acl(struct tomoyo_request_info *r, const u8 type,
-                                 const struct tomoyo_path_info *filename,
-                                 const unsigned long number)
-{
-       struct tomoyo_domain_info *domain = r->domain;
-       struct tomoyo_acl_info *ptr;
-       const u8 perm = 1 << type;
-       int error = -EPERM;
-       list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {
-               struct tomoyo_path_number_acl *acl;
-               if (ptr->type != TOMOYO_TYPE_PATH_NUMBER_ACL)
-                       continue;
-               acl = container_of(ptr, struct tomoyo_path_number_acl,
-                                  head);
-               if (!(acl->perm & perm) ||
-                   !tomoyo_compare_number_union(number, &acl->number) ||
-                   !tomoyo_compare_name_union(filename, &acl->name))
-                       continue;
-               error = 0;
-               break;
-       }
-       return error;
-}
-
 static bool tomoyo_same_path_number_acl(const struct tomoyo_acl_info *a,
                                        const struct tomoyo_acl_info *b)
 {
@@ -1047,9 +809,9 @@ 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_is_same_acl_head(&p1->head, &p2->head)
-               && tomoyo_is_same_name_union(&p1->name, &p2->name)
-               && tomoyo_is_same_number_union(&p1->number, &p2->number);
+       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);
 }
 
 static bool tomoyo_merge_path_number_acl(struct tomoyo_acl_info *a,
@@ -1104,58 +866,6 @@ static int tomoyo_update_path_number_acl(const u8 type, const char *filename,
        return error;
 }
 
-/**
- * tomoyo_path_number_perm2 - Check permission for "create", "mkdir", "mkfifo", "mksock", "ioctl", "chmod", "chown", "chgrp".
- *
- * @r:        Pointer to "strct tomoyo_request_info".
- * @filename: Filename to check.
- * @number:   Number.
- *
- * Returns 0 on success, negative value otherwise.
- *
- * Caller holds tomoyo_read_lock().
- */
-static int tomoyo_path_number_perm2(struct tomoyo_request_info *r,
-                                   const u8 type,
-                                   const struct tomoyo_path_info *filename,
-                                   const unsigned long number)
-{
-       char buffer[64];
-       int error;
-       u8 radix;
-       const char *msg;
-
-       if (!filename)
-               return 0;
-       switch (type) {
-       case TOMOYO_TYPE_CREATE:
-       case TOMOYO_TYPE_MKDIR:
-       case TOMOYO_TYPE_MKFIFO:
-       case TOMOYO_TYPE_MKSOCK:
-       case TOMOYO_TYPE_CHMOD:
-               radix = TOMOYO_VALUE_TYPE_OCTAL;
-               break;
-       case TOMOYO_TYPE_IOCTL:
-               radix = TOMOYO_VALUE_TYPE_HEXADECIMAL;
-               break;
-       default:
-               radix = TOMOYO_VALUE_TYPE_DECIMAL;
-               break;
-       }
-       tomoyo_print_ulong(buffer, sizeof(buffer), number, radix);
-       do {
-               error = tomoyo_path_number_acl(r, type, filename, number);
-               if (!error)
-                       break;
-               msg = tomoyo_path_number2keyword(type);
-               tomoyo_warn_log(r, "%s %s %s", msg, filename->name, buffer);
-               error = tomoyo_supervisor(r, "allow_%s %s %s\n", msg,
-                                         tomoyo_file_pattern(filename),
-                                         buffer);
-       } while (error == TOMOYO_RETRY_REQUEST);
-       return error;
-}
-
 /**
  * tomoyo_path_number_perm - Check permission for "create", "mkdir", "mkfifo", "mksock", "ioctl", "chmod", "chown", "chgrp".
  *
@@ -1181,9 +891,16 @@ int tomoyo_path_number_perm(const u8 type, struct path *path,
                goto out;
        if (type == TOMOYO_TYPE_MKDIR)
                tomoyo_add_slash(&buf);
-       error = tomoyo_path_number_perm2(&r, type, &buf, number);
- out:
+       r.param_type = TOMOYO_TYPE_PATH_NUMBER_ACL;
+       r.param.path_number.operation = type;
+       r.param.path_number.filename = &buf;
+       r.param.path_number.number = number;
+       do {
+               tomoyo_check_acl(&r, tomoyo_check_path_number_acl);
+               error = tomoyo_audit_path_number_log(&r);
+       } while (error == TOMOYO_RETRY_REQUEST);
        kfree(buf.name);
+ out:
        tomoyo_read_unlock(idx);
        if (r.mode != TOMOYO_CONFIG_ENFORCING)
                error = 0;
@@ -1229,7 +946,7 @@ int tomoyo_check_open_permission(struct tomoyo_domain_info *domain,
                        error = -ENOMEM;
                        goto out;
                }
-               if (tomoyo_is_no_rewrite_file(&buf))
+               if (tomoyo_no_rewrite_file(&buf))
                        error = tomoyo_path_permission(&r, TOMOYO_TYPE_REWRITE,
                                                       &buf);
        }
@@ -1283,7 +1000,7 @@ int tomoyo_path_perm(const u8 operation, struct path *path)
                goto out;
        switch (operation) {
        case TOMOYO_TYPE_REWRITE:
-               if (!tomoyo_is_no_rewrite_file(&buf)) {
+               if (!tomoyo_no_rewrite_file(&buf)) {
                        error = 0;
                        goto out;
                }
@@ -1304,48 +1021,7 @@ int tomoyo_path_perm(const u8 operation, struct path *path)
 }
 
 /**
- * tomoyo_path_number3_perm2 - Check permission for path/number/number/number operation.
- *
- * @r:         Pointer to "struct tomoyo_request_info".
- * @operation: Type of operation.
- * @filename:  Filename to check.
- * @mode:      Create mode.
- * @dev:       Device number.
- *
- * Returns 0 on success, negative value otherwise.
- *
- * Caller holds tomoyo_read_lock().
- */
-static int tomoyo_path_number3_perm2(struct tomoyo_request_info *r,
-                                    const u8 operation,
-                                    const struct tomoyo_path_info *filename,
-                                    const unsigned int mode,
-                                    const unsigned int dev)
-{
-       int error;
-       const char *msg;
-       const unsigned int major = MAJOR(dev);
-       const unsigned int minor = MINOR(dev);
-
-       do {
-               error = tomoyo_path_number3_acl(r, filename, 1 << operation,
-                                               mode, major, minor);
-               if (!error)
-                       break;
-               msg = tomoyo_path_number32keyword(operation);
-               tomoyo_warn_log(r, "%s %s 0%o %u %u", msg, filename->name,
-                               mode, major, minor);
-               error = tomoyo_supervisor(r, "allow_%s %s 0%o %u %u\n", msg,
-                                         tomoyo_file_pattern(filename), mode,
-                                         major, minor);
-       } while (error == TOMOYO_RETRY_REQUEST);
-        if (r->mode != TOMOYO_CONFIG_ENFORCING)
-               error = 0;
-       return error;
-}
-
-/**
- * tomoyo_path_number3_perm - Check permission for "mkblock" and "mkchar".
+ * tomoyo_mkdev_perm - Check permission for "mkblock" and "mkchar".
  *
  * @operation: Type of operation. (TOMOYO_TYPE_MKCHAR or TOMOYO_TYPE_MKBLOCK)
  * @path:      Pointer to "struct path".
@@ -1354,7 +1030,7 @@ static int tomoyo_path_number3_perm2(struct tomoyo_request_info *r,
  *
  * Returns 0 on success, negative value otherwise.
  */
-int tomoyo_path_number3_perm(const u8 operation, struct path *path,
+int tomoyo_mkdev_perm(const u8 operation, struct path *path,
                             const unsigned int mode, unsigned int dev)
 {
        struct tomoyo_request_info r;
@@ -1369,8 +1045,15 @@ int tomoyo_path_number3_perm(const u8 operation, struct path *path,
        idx = tomoyo_read_lock();
        error = -ENOMEM;
        if (tomoyo_get_realpath(&buf, path)) {
-               error = tomoyo_path_number3_perm2(&r, operation, &buf, mode,
-                                                 new_decode_dev(dev));
+               dev = new_decode_dev(dev);
+               r.param_type = TOMOYO_TYPE_MKDEV_ACL;
+               r.param.mkdev.filename = &buf;
+               r.param.mkdev.operation = operation;
+               r.param.mkdev.mode = mode;
+               r.param.mkdev.major = MAJOR(dev);
+               r.param.mkdev.minor = MINOR(dev);
+               tomoyo_check_acl(&r, tomoyo_check_mkdev_acl);
+               error = tomoyo_audit_mkdev_log(&r);
                kfree(buf.name);
        }
        tomoyo_read_unlock(idx);
@@ -1392,7 +1075,6 @@ int tomoyo_path2_perm(const u8 operation, struct path *path1,
                      struct path *path2)
 {
        int error = -ENOMEM;
-       const char *msg;
        struct tomoyo_path_info buf1;
        struct tomoyo_path_info buf2;
        struct tomoyo_request_info r;
@@ -1421,16 +1103,14 @@ int tomoyo_path2_perm(const u8 operation, struct path *path1,
                 tomoyo_add_slash(&buf2);
                break;
         }
+       r.param_type = TOMOYO_TYPE_PATH2_ACL;
+       r.param.path2.operation = operation;
+       r.param.path2.filename1 = &buf1;
+       r.param.path2.filename2 = &buf2;
        do {
-               error = tomoyo_path2_acl(&r, operation, &buf1, &buf2);
-               if (!error)
-                       break;
-               msg = tomoyo_path22keyword(operation);
-               tomoyo_warn_log(&r, "%s %s %s", msg, buf1.name, buf2.name);
-               error = tomoyo_supervisor(&r, "allow_%s %s %s\n", msg,
-                                         tomoyo_file_pattern(&buf1),
-                                         tomoyo_file_pattern(&buf2));
-        } while (error == TOMOYO_RETRY_REQUEST);
+               tomoyo_check_acl(&r, tomoyo_check_path2_acl);
+               error = tomoyo_audit_path2_log(&r);
+       } while (error == TOMOYO_RETRY_REQUEST);
  out:
        kfree(buf1.name);
        kfree(buf2.name);
@@ -1482,11 +1162,11 @@ int tomoyo_write_file_policy(char *data, struct tomoyo_domain_info *domain,
        }
        if (!w[3][0] || !w[4][0])
                goto out;
-       for (type = 0; type < TOMOYO_MAX_PATH_NUMBER3_OPERATION; type++) {
-               if (strcmp(w[0], tomoyo_path_number3_keyword[type]))
+       for (type = 0; type < TOMOYO_MAX_MKDEV_OPERATION; type++) {
+               if (strcmp(w[0], tomoyo_mkdev_keyword[type]))
                        continue;
-               return tomoyo_update_path_number3_acl(type, w[1], w[2], w[3],
-                                                     w[4], domain, is_delete);
+               return tomoyo_update_mkdev_acl(type, w[1], w[2], w[3],
+                                              w[4], domain, is_delete);
        }
  out:
        return -EINVAL;