Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 237ab459 authored by Tetsuo Handa's avatar Tetsuo Handa Committed by James Morris
Browse files

TOMOYO: Use callback for updating entries. 



Use common "struct list_head" + "bool" + "u8" structure and
use common code for elements using that structure.

Signed-off-by: default avatarTetsuo Handa <penguin-kernel@I-love.SAKURA.ne.jp>
Signed-off-by: default avatarJames Morris <jmorris@namei.org>
parent 927942aa

security/tomoyo/common.c

+2 −2
Original line number Diff line number Diff line
@@ -950,8 +950,6 @@ static bool tomoyo_print_mount_acl(struct tomoyo_io_buffer *head, 
				   struct tomoyo_mount_acl *ptr)

{

	const int pos = head->read_avail;

	if (ptr->is_deleted)

		return true;

	if (!tomoyo_io_printf(head, TOMOYO_KEYWORD_ALLOW_MOUNT) ||

	    !tomoyo_print_name_union(head, &ptr->dev_name) ||

	    !tomoyo_print_name_union(head, &ptr->dir_name) ||
@@ -977,6 +975,8 @@ static bool tomoyo_print_entry(struct tomoyo_io_buffer *head, 
{

	const u8 acl_type = ptr->type;



	if (ptr->is_deleted)

		return true;

	if (acl_type == TOMOYO_TYPE_PATH_ACL) {

		struct tomoyo_path_acl *acl

			= container_of(ptr, struct tomoyo_path_acl, head);

security/tomoyo/common.h

+24 −58
Original line number Diff line number Diff line
@@ -112,6 +112,8 @@ enum tomoyo_path_acl_index { 
	TOMOYO_MAX_PATH_OPERATION

};



#define TOMOYO_RW_MASK ((1 << TOMOYO_TYPE_READ) | (1 << TOMOYO_TYPE_WRITE))



enum tomoyo_path_number3_acl_index {

	TOMOYO_TYPE_MKBLOCK,

	TOMOYO_TYPE_MKCHAR,
@@ -289,17 +291,19 @@ struct tomoyo_number_group_member { 
 *

 *  (1) "list" which is linked to the ->acl_info_list of

 *      "struct tomoyo_domain_info"

 *  (2) "type" which tells type of the entry (either

 *      "struct tomoyo_path_acl" or "struct tomoyo_path2_acl").

 *  (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 "u8" + "u16" and

 * "struct tomoyo_path2_acl" to embed "u8"

 * without enlarging their structure size.

 * "struct tomoyo_path_acl" to embed "u16" and "struct tomoyo_path2_acl"

 * "struct tomoyo_path_number_acl" "struct tomoyo_path_number3_acl" to embed

 * "u8" without enlarging their structure size.

 */

struct tomoyo_acl_info {

	struct list_head list;

	u8 type;

	bool is_deleted;

	u8 type; /* = one of values in "enum tomoyo_acl_entry_type_index". */

} __packed;



/*
@@ -438,17 +442,15 @@ struct tomoyo_path2_acl { 
 * It has following fields.

 *

 *  (1) "head" which is a "struct tomoyo_acl_info".

 *  (2) "is_deleted" is boolean.

 *  (3) "dev_name" is the device name.

 *  (4) "dir_name" is the mount point.

 *  (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.

 *

 * Directives held by this structure are "allow_rename", "allow_link" and

 * "allow_pivot_root".

 * Directive held by this structure is "allow_mount".

 */

struct tomoyo_mount_acl {

	struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_MOUNT_ACL */

	bool is_deleted;

	struct tomoyo_name_union dev_name;

	struct tomoyo_name_union dir_name;

	struct tomoyo_name_union fs_type;
@@ -914,6 +916,16 @@ void tomoyo_run_gc(void); 


void tomoyo_memory_free(void *ptr);



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));



/********** External variable definitions. **********/



/* Lock for GC. */
@@ -1042,52 +1054,6 @@ static inline bool tomoyo_is_same_number_union 
		p1->max_type == p2->max_type && p1->is_group == p2->is_group;

}



static inline bool tomoyo_is_same_path_acl(const struct tomoyo_path_acl *p1,

					   const struct tomoyo_path_acl *p2)

{

	return tomoyo_is_same_acl_head(&p1->head, &p2->head) &&

		tomoyo_is_same_name_union(&p1->name, &p2->name);

}



static inline bool tomoyo_is_same_path_number3_acl

(const struct tomoyo_path_number3_acl *p1,

 const struct tomoyo_path_number3_acl *p2)

{

	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);

}





static inline bool tomoyo_is_same_path2_acl(const struct tomoyo_path2_acl *p1,

					    const struct tomoyo_path2_acl *p2)

{

	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);

}



static inline bool tomoyo_is_same_path_number_acl

(const struct tomoyo_path_number_acl *p1,

 const struct tomoyo_path_number_acl *p2)

{

	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);

}



static inline bool tomoyo_is_same_mount_acl(const struct tomoyo_mount_acl *p1,

					    const struct tomoyo_mount_acl *p2)

{

	return tomoyo_is_same_acl_head(&p1->head, &p2->head) &&

		tomoyo_is_same_name_union(&p1->dev_name, &p2->dev_name) &&

		tomoyo_is_same_name_union(&p1->dir_name, &p2->dir_name) &&

		tomoyo_is_same_name_union(&p1->fs_type, &p2->fs_type) &&

		tomoyo_is_same_number_union(&p1->flags, &p2->flags);

}



static inline bool tomoyo_is_same_domain_initializer_entry

(const struct tomoyo_domain_initializer_entry *p1,

 const struct tomoyo_domain_initializer_entry *p2)

security/tomoyo/domain.c

+51 −0
Original line number Diff line number Diff line
@@ -15,6 +15,57 @@ 
/* The initial domain. */

struct tomoyo_domain_info tomoyo_kernel_domain;



/**

 * 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".

 * @check_duplicate: Callback function to find duplicated entry.

 * @merge_duplicate: Callback function to merge duplicated entry.

 *

 * Returns 0 on success, negative value otherwise.

 *

 * Caller holds tomoyo_read_lock().

 */

int tomoyo_update_domain(struct tomoyo_acl_info *new_entry, const int size,

			 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))

{

	int error = is_delete ? -ENOENT : -ENOMEM;

	struct tomoyo_acl_info *entry;



	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))

			continue;

		if (merge_duplicate)

			entry->is_deleted = merge_duplicate(entry, new_entry,

							    is_delete);

		else

			entry->is_deleted = is_delete;

		error = 0;

		break;

	}

	if (error && !is_delete) {

		entry = tomoyo_commit_ok(new_entry, size);

		if (entry) {

			list_add_tail_rcu(&entry->list, &domain->acl_info_list);

			error = 0;

		}

	}

	mutex_unlock(&tomoyo_policy_lock);

	return error;

}



/*

 * tomoyo_domain_list is used for holding list of domains.

 * The ->acl_info_list of "struct tomoyo_domain_info" is used for holding

security/tomoyo/file.c

+153 −196
Original line number Diff line number Diff line
@@ -664,50 +664,6 @@ bool tomoyo_read_no_rewrite_policy(struct tomoyo_io_buffer *head) 
	return done;

}



/**

 * tomoyo_update_file_acl - Update file's read/write/execute ACL.

 *

 * @perm:      Permission (between 1 to 7).

 * @filename:  Filename.

 * @domain:    Pointer to "struct tomoyo_domain_info".

 * @is_delete: True if it is a delete request.

 *

 * Returns 0 on success, negative value otherwise.

 *

 * This is legacy support interface for older policy syntax.

 * Current policy syntax uses "allow_read/write" instead of "6",

 * "allow_read" instead of "4", "allow_write" instead of "2",

 * "allow_execute" instead of "1".

 *

 * Caller holds tomoyo_read_lock().

 */

static int tomoyo_update_file_acl(u8 perm, const char *filename,

				  struct tomoyo_domain_info * const domain,

				  const bool is_delete)

{

	if (perm > 7 || !perm) {

		printk(KERN_DEBUG "%s: Invalid permission '%d %s'\n",

		       __func__, perm, filename);

		return -EINVAL;

	}

	if (filename[0] != '@' && tomoyo_strendswith(filename, "/"))

		/*

		 * Only 'allow_mkdir' and 'allow_rmdir' are valid for

		 * directory permissions.

		 */

		return 0;

	if (perm & 4)

		tomoyo_update_path_acl(TOMOYO_TYPE_READ, filename, domain,

				       is_delete);

	if (perm & 2)

		tomoyo_update_path_acl(TOMOYO_TYPE_WRITE, filename, domain,

				       is_delete);

	if (perm & 1)

		tomoyo_update_path_acl(TOMOYO_TYPE_EXECUTE, filename, domain,

				       is_delete);

	return 0;

}



/**

 * tomoyo_path_acl - Check permission for single path operation.

 *
@@ -797,6 +753,40 @@ static int tomoyo_file_perm(struct tomoyo_request_info *r, 
	return error;

}



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_is_same_acl_head(&p1->head, &p2->head) &&

		tomoyo_is_same_name_union(&p1->name, &p2->name);

}



static bool tomoyo_merge_path_acl(struct tomoyo_acl_info *a,

				  struct tomoyo_acl_info *b,

				  const bool is_delete)

{

	u16 * const a_perm = &container_of(a, struct tomoyo_path_acl, head)

		->perm;

	u16 perm = *a_perm;

	const u16 b_perm = container_of(b, struct tomoyo_path_acl, head)->perm;

	if (is_delete) {

		perm &= ~b_perm;

		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 {

		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;

}



/**

 * tomoyo_update_path_acl - Update "struct tomoyo_path_acl" list.

 *
@@ -813,60 +803,53 @@ static int tomoyo_update_path_acl(const u8 type, const char *filename, 
				  struct tomoyo_domain_info * const domain,

				  const bool is_delete)

{

	static const u16 tomoyo_rw_mask =

		(1 << TOMOYO_TYPE_READ) | (1 << TOMOYO_TYPE_WRITE);

	const u16 perm = 1 << type;

	struct tomoyo_acl_info *ptr;

	struct tomoyo_path_acl e = {

		.head.type = TOMOYO_TYPE_PATH_ACL,

		.perm = perm

		.perm = 1 << type

	};

	int error = is_delete ? -ENOENT : -ENOMEM;



	if (type == TOMOYO_TYPE_READ_WRITE)

		e.perm |= tomoyo_rw_mask;

	if (!domain)

		return -EINVAL;

	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;

	if (mutex_lock_interruptible(&tomoyo_policy_lock))

		goto out;

	list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {

		struct tomoyo_path_acl *acl =

			container_of(ptr, struct tomoyo_path_acl, head);

		if (!tomoyo_is_same_path_acl(acl, &e))

			continue;

		if (is_delete) {

			acl->perm &= ~perm;

			if ((acl->perm & tomoyo_rw_mask) != tomoyo_rw_mask)

				acl->perm &= ~(1 << TOMOYO_TYPE_READ_WRITE);

			else if (!(acl->perm & (1 << TOMOYO_TYPE_READ_WRITE)))

				acl->perm &= ~tomoyo_rw_mask;

		} else {

			acl->perm |= perm;

			if ((acl->perm & tomoyo_rw_mask) == tomoyo_rw_mask)

				acl->perm |= 1 << TOMOYO_TYPE_READ_WRITE;

			else if (acl->perm & (1 << TOMOYO_TYPE_READ_WRITE))

				acl->perm |= tomoyo_rw_mask;

		}

		error = 0;

		break;

	}

	if (!is_delete && error) {

		struct tomoyo_path_acl *entry =

			tomoyo_commit_ok(&e, sizeof(e));

		if (entry) {

			list_add_tail_rcu(&entry->head.list,

					  &domain->acl_info_list);

			error = 0;

		}

	}

	mutex_unlock(&tomoyo_policy_lock);

 out:

	error = tomoyo_update_domain(&e.head, sizeof(e), is_delete, domain,

				     tomoyo_same_path_acl,

				     tomoyo_merge_path_acl);

	tomoyo_put_name_union(&e.name);

	return error;

}



static bool tomoyo_same_path_number3_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),

								head);

	const struct tomoyo_path_number3_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);

}



static bool tomoyo_merge_path_number3_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,

					 head)->perm;

	u8 perm = *a_perm;

	const u8 b_perm = container_of(b, struct tomoyo_path_number3_acl, head)

		->perm;

	if (is_delete)

		perm &= ~b_perm;

	else

		perm |= b_perm;

	*a_perm = perm;

	return !perm;

}



/**

 * tomoyo_update_path_number3_acl - Update "struct tomoyo_path_number3_acl" list.

 *
@@ -879,20 +862,17 @@ static int tomoyo_update_path_acl(const u8 type, const char *filename, 
 * @is_delete: True if it is a delete request.

 *

 * Returns 0 on success, negative value otherwise.

 *

 * Caller holds tomoyo_read_lock().

 */

static inline int tomoyo_update_path_number3_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_path_number3_acl(const u8 type, const char *filename,

					  char *mode, char *major, char *minor,

					  struct tomoyo_domain_info * const

					  domain, const bool is_delete)

{

	const u8 perm = 1 << type;

	struct tomoyo_acl_info *ptr;

	struct tomoyo_path_number3_acl e = {

		.head.type = TOMOYO_TYPE_PATH_NUMBER3_ACL,

		.perm = perm

		.perm = 1 << type

	};

	int error = is_delete ? -ENOENT : -ENOMEM;

	if (!tomoyo_parse_name_union(filename, &e.name) ||
@@ -900,30 +880,9 @@ static inline int tomoyo_update_path_number3_acl(const u8 type, 
	    !tomoyo_parse_number_union(major, &e.major) ||

	    !tomoyo_parse_number_union(minor, &e.minor))

		goto out;

	if (mutex_lock_interruptible(&tomoyo_policy_lock))

		goto out;

	list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {

		struct tomoyo_path_number3_acl *acl =

			container_of(ptr, struct tomoyo_path_number3_acl, head);

		if (!tomoyo_is_same_path_number3_acl(acl, &e))

			continue;

		if (is_delete)

			acl->perm &= ~perm;

		else

			acl->perm |= perm;

		error = 0;

		break;

	}

	if (!is_delete && error) {

		struct tomoyo_path_number3_acl *entry =

			tomoyo_commit_ok(&e, sizeof(e));

		if (entry) {

			list_add_tail_rcu(&entry->head.list,

					  &domain->acl_info_list);

			error = 0;

		}

	}

	mutex_unlock(&tomoyo_policy_lock);

	error = tomoyo_update_domain(&e.head, sizeof(e), is_delete, domain,

				     tomoyo_same_path_number3_acl,

				     tomoyo_merge_path_number3_acl);

 out:

	tomoyo_put_name_union(&e.name);

	tomoyo_put_number_union(&e.mode);
@@ -932,6 +891,32 @@ static inline int tomoyo_update_path_number3_acl(const u8 type, 
	return error;

}



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_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);

}



static bool tomoyo_merge_path2_acl(struct tomoyo_acl_info *a,

				   struct tomoyo_acl_info *b,

				   const bool is_delete)

{

	u8 * const a_perm = &container_of(a, struct tomoyo_path2_acl, head)

		->perm;

	u8 perm = *a_perm;

	const u8 b_perm = container_of(b, struct tomoyo_path2_acl, head)->perm;

	if (is_delete)

		perm &= ~b_perm;

	else

		perm |= b_perm;

	*a_perm = perm;

	return !perm;

}



/**

 * tomoyo_update_path2_acl - Update "struct tomoyo_path2_acl" list.

 *
@@ -950,43 +935,17 @@ static int tomoyo_update_path2_acl(const u8 type, const char *filename1, 
				   struct tomoyo_domain_info * const domain,

				   const bool is_delete)

{

	const u8 perm = 1 << type;

	struct tomoyo_path2_acl e = {

		.head.type = TOMOYO_TYPE_PATH2_ACL,

		.perm = perm

		.perm = 1 << type

	};

	struct tomoyo_acl_info *ptr;

	int error = is_delete ? -ENOENT : -ENOMEM;



	if (!domain)

		return -EINVAL;

	if (!tomoyo_parse_name_union(filename1, &e.name1) ||

	    !tomoyo_parse_name_union(filename2, &e.name2))

		goto out;

	if (mutex_lock_interruptible(&tomoyo_policy_lock))

		goto out;

	list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {

		struct tomoyo_path2_acl *acl =

			container_of(ptr, struct tomoyo_path2_acl, head);

		if (!tomoyo_is_same_path2_acl(acl, &e))

			continue;

		if (is_delete)

			acl->perm &= ~perm;

		else

			acl->perm |= perm;

		error = 0;

		break;

	}

	if (!is_delete && error) {

		struct tomoyo_path2_acl *entry =

			tomoyo_commit_ok(&e, sizeof(e));

		if (entry) {

			list_add_tail_rcu(&entry->head.list,

					  &domain->acl_info_list);

			error = 0;

		}

	}

	mutex_unlock(&tomoyo_policy_lock);

	error = tomoyo_update_domain(&e.head, sizeof(e), is_delete, domain,

				     tomoyo_same_path2_acl,

				     tomoyo_merge_path2_acl);

 out:

	tomoyo_put_name_union(&e.name1);

	tomoyo_put_name_union(&e.name2);
@@ -1157,6 +1116,35 @@ static int tomoyo_path_number_acl(struct tomoyo_request_info *r, const u8 type, 
	return error;

}



static bool tomoyo_same_path_number_acl(const struct tomoyo_acl_info *a,

					const struct tomoyo_acl_info *b)

{

	const struct tomoyo_path_number_acl *p1 = container_of(a, typeof(*p1),

							       head);

	const struct tomoyo_path_number_acl *p2 = container_of(b, typeof(*p2),

							       head);

	return tomoyo_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);

}



static bool tomoyo_merge_path_number_acl(struct tomoyo_acl_info *a,

					 struct tomoyo_acl_info *b,

					 const bool is_delete)

{

	u8 * const a_perm = &container_of(a, struct tomoyo_path_number_acl,

					  head)->perm;

	u8 perm = *a_perm;

	const u8 b_perm = container_of(b, struct tomoyo_path_number_acl, head)

		->perm;

	if (is_delete)

		perm &= ~b_perm;

	else

		perm |= b_perm;

	*a_perm = perm;

	return !perm;

}



/**

 * tomoyo_update_path_number_acl - Update ioctl/chmod/chown/chgrp ACL.

 *
@@ -1168,50 +1156,24 @@ static int tomoyo_path_number_acl(struct tomoyo_request_info *r, const u8 type, 
 *

 * Returns 0 on success, negative value otherwise.

 */

static inline int tomoyo_update_path_number_acl(const u8 type,

						const char *filename,

static int tomoyo_update_path_number_acl(const u8 type, const char *filename,

					 char *number,

						struct tomoyo_domain_info *

						const domain,

					 struct tomoyo_domain_info * const

					 domain,

					 const bool is_delete)

{

	const u8 perm = 1 << type;

	struct tomoyo_acl_info *ptr;

	struct tomoyo_path_number_acl e = {

		.head.type = TOMOYO_TYPE_PATH_NUMBER_ACL,

		.perm = perm

		.perm = 1 << type

	};

	int error = is_delete ? -ENOENT : -ENOMEM;

	if (!domain)

		return -EINVAL;

	if (!tomoyo_parse_name_union(filename, &e.name))

		return -EINVAL;

	if (!tomoyo_parse_number_union(number, &e.number))

		goto out;

	if (mutex_lock_interruptible(&tomoyo_policy_lock))

		goto out;

	list_for_each_entry_rcu(ptr, &domain->acl_info_list, list) {

		struct tomoyo_path_number_acl *acl =

			container_of(ptr, struct tomoyo_path_number_acl, head);

		if (!tomoyo_is_same_path_number_acl(acl, &e))

			continue;

		if (is_delete)

			acl->perm &= ~perm;

		else

			acl->perm |= perm;

		error = 0;

		break;

	}

	if (!is_delete && error) {

		struct tomoyo_path_number_acl *entry =

			tomoyo_commit_ok(&e, sizeof(e));

		if (entry) {

			list_add_tail_rcu(&entry->head.list,

					  &domain->acl_info_list);

			error = 0;

		}

	}

	mutex_unlock(&tomoyo_policy_lock);

	error = tomoyo_update_domain(&e.head, sizeof(e), is_delete, domain,

				     tomoyo_same_path_number_acl,

				     tomoyo_merge_path_number_acl);

 out:

	tomoyo_put_name_union(&e.name);

	tomoyo_put_number_union(&e.number);
@@ -1585,13 +1547,8 @@ int tomoyo_write_file_policy(char *data, struct tomoyo_domain_info *domain, 
	u8 type;

	if (!tomoyo_tokenize(data, w, sizeof(w)) || !w[1][0])

		return -EINVAL;

	if (strncmp(w[0], "allow_", 6)) {

		unsigned int perm;

		if (sscanf(w[0], "%u", &perm) == 1)

			return tomoyo_update_file_acl((u8) perm, w[1], domain,

						      is_delete);

	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]))

security/tomoyo/gc.c

+1 −27
Original line number Diff line number Diff line
@@ -310,34 +310,8 @@ static void tomoyo_collect_entry(void) 
			struct tomoyo_acl_info *acl;

			list_for_each_entry_rcu(acl, &domain->acl_info_list,

						list) {

				switch (acl->type) {

				case TOMOYO_TYPE_PATH_ACL:

					if (container_of(acl,

					 struct tomoyo_path_acl,

							 head)->perm)

						continue;

					break;

				case TOMOYO_TYPE_PATH2_ACL:

					if (container_of(acl,

					 struct tomoyo_path2_acl,

							 head)->perm)

						continue;

					break;

				case TOMOYO_TYPE_PATH_NUMBER_ACL:

					if (container_of(acl,

					 struct tomoyo_path_number_acl,

							 head)->perm)

				if (!acl->is_deleted)

					continue;

					break;

				case TOMOYO_TYPE_PATH_NUMBER3_ACL:

					if (container_of(acl,

					 struct tomoyo_path_number3_acl,

							 head)->perm)

						continue;

					break;

				default:

					continue;

				}

				if (tomoyo_add_to_gc(TOMOYO_ID_ACL, acl))

					list_del_rcu(&acl->list);

				else