2 * security/tomoyo/memory.c
4 * Memory management functions for TOMOYO.
6 * Copyright (C) 2005-2010 NTT DATA CORPORATION
9 #include <linux/hash.h>
10 #include <linux/slab.h>
14 * tomoyo_warn_oom - Print out of memory warning message.
16 * @function: Function's name.
18 void tomoyo_warn_oom(const char *function)
20 /* Reduce error messages. */
21 static pid_t tomoyo_last_pid;
22 const pid_t pid = current->pid;
23 if (tomoyo_last_pid != pid) {
24 printk(KERN_WARNING "ERROR: Out of memory at %s.\n",
26 tomoyo_last_pid = pid;
28 if (!tomoyo_policy_loaded)
29 panic("MAC Initialization failed.\n");
32 /* Memory allocated for policy. */
33 static atomic_t tomoyo_policy_memory_size;
34 /* Quota for holding policy. */
35 static unsigned int tomoyo_quota_for_policy;
38 * tomoyo_memory_ok - Check memory quota.
40 * @ptr: Pointer to allocated memory.
42 * Returns true on success, false otherwise.
44 * Returns true if @ptr is not NULL and quota not exceeded, false otherwise.
46 bool tomoyo_memory_ok(void *ptr)
48 size_t s = ptr ? ksize(ptr) : 0;
49 atomic_add(s, &tomoyo_policy_memory_size);
50 if (ptr && (!tomoyo_quota_for_policy ||
51 atomic_read(&tomoyo_policy_memory_size)
52 <= tomoyo_quota_for_policy)) {
56 atomic_sub(s, &tomoyo_policy_memory_size);
57 tomoyo_warn_oom(__func__);
62 * tomoyo_commit_ok - Check memory quota.
64 * @data: Data to copy from.
65 * @size: Size in byte.
67 * Returns pointer to allocated memory on success, NULL otherwise.
68 * @data is zero-cleared on success.
70 void *tomoyo_commit_ok(void *data, const unsigned int size)
72 void *ptr = kzalloc(size, GFP_NOFS);
73 if (tomoyo_memory_ok(ptr)) {
74 memmove(ptr, data, size);
75 memset(data, 0, size);
83 * tomoyo_memory_free - Free memory for elements.
85 * @ptr: Pointer to allocated memory.
87 void tomoyo_memory_free(void *ptr)
89 atomic_sub(ksize(ptr), &tomoyo_policy_memory_size);
94 * tomoyo_get_group - Allocate memory for "struct tomoyo_path_group"/"struct tomoyo_number_group".
96 * @param: Pointer to "struct tomoyo_acl_param".
99 * Returns pointer to "struct tomoyo_group" on success, NULL otherwise.
101 struct tomoyo_group *tomoyo_get_group(struct tomoyo_acl_param *param,
104 struct tomoyo_group e = { };
105 struct tomoyo_group *group = NULL;
106 struct list_head *list;
107 const char *group_name = tomoyo_read_token(param);
109 if (!tomoyo_correct_word(group_name) || idx >= TOMOYO_MAX_GROUP)
111 e.group_name = tomoyo_get_name(group_name);
114 if (mutex_lock_interruptible(&tomoyo_policy_lock))
116 list = &tomoyo_group_list[idx];
117 list_for_each_entry(group, list, head.list) {
118 if (e.group_name != group->group_name)
120 atomic_inc(&group->head.users);
125 struct tomoyo_group *entry = tomoyo_commit_ok(&e, sizeof(e));
127 INIT_LIST_HEAD(&entry->member_list);
128 atomic_set(&entry->head.users, 1);
129 list_add_tail_rcu(&entry->head.list, list);
134 mutex_unlock(&tomoyo_policy_lock);
136 tomoyo_put_name(e.group_name);
137 return found ? group : NULL;
141 * tomoyo_name_list is used for holding string data used by TOMOYO.
142 * Since same string data is likely used for multiple times (e.g.
143 * "/lib/libc-2.5.so"), TOMOYO shares string data in the form of
144 * "const struct tomoyo_path_info *".
146 struct list_head tomoyo_name_list[TOMOYO_MAX_HASH];
149 * tomoyo_get_name - Allocate permanent memory for string data.
151 * @name: The string to store into the permernent memory.
153 * Returns pointer to "struct tomoyo_path_info" on success, NULL otherwise.
155 const struct tomoyo_path_info *tomoyo_get_name(const char *name)
157 struct tomoyo_name *ptr;
161 struct list_head *head;
165 len = strlen(name) + 1;
166 hash = full_name_hash((const unsigned char *) name, len - 1);
167 head = &tomoyo_name_list[hash_long(hash, TOMOYO_HASH_BITS)];
168 if (mutex_lock_interruptible(&tomoyo_policy_lock))
170 list_for_each_entry(ptr, head, head.list) {
171 if (hash != ptr->entry.hash || strcmp(name, ptr->entry.name))
173 atomic_inc(&ptr->head.users);
176 ptr = kzalloc(sizeof(*ptr) + len, GFP_NOFS);
177 allocated_len = ptr ? ksize(ptr) : 0;
178 if (!ptr || (tomoyo_quota_for_policy &&
179 atomic_read(&tomoyo_policy_memory_size) + allocated_len
180 > tomoyo_quota_for_policy)) {
183 tomoyo_warn_oom(__func__);
186 atomic_add(allocated_len, &tomoyo_policy_memory_size);
187 ptr->entry.name = ((char *) ptr) + sizeof(*ptr);
188 memmove((char *) ptr->entry.name, name, len);
189 atomic_set(&ptr->head.users, 1);
190 tomoyo_fill_path_info(&ptr->entry);
191 list_add_tail(&ptr->head.list, head);
193 mutex_unlock(&tomoyo_policy_lock);
194 return ptr ? &ptr->entry : NULL;
198 * tomoyo_mm_init - Initialize mm related code.
200 void __init tomoyo_mm_init(void)
204 for (idx = 0; idx < TOMOYO_MAX_POLICY; idx++)
205 INIT_LIST_HEAD(&tomoyo_policy_list[idx]);
206 for (idx = 0; idx < TOMOYO_MAX_GROUP; idx++)
207 INIT_LIST_HEAD(&tomoyo_group_list[idx]);
208 for (idx = 0; idx < TOMOYO_MAX_HASH; idx++)
209 INIT_LIST_HEAD(&tomoyo_name_list[idx]);
210 INIT_LIST_HEAD(&tomoyo_kernel_domain.acl_info_list);
211 tomoyo_kernel_domain.domainname = tomoyo_get_name(TOMOYO_ROOT_NAME);
212 list_add_tail_rcu(&tomoyo_kernel_domain.list, &tomoyo_domain_list);
213 idx = tomoyo_read_lock();
214 if (tomoyo_find_domain(TOMOYO_ROOT_NAME) != &tomoyo_kernel_domain)
215 panic("Can't register tomoyo_kernel_domain");
217 /* Will be replaced with tomoyo_load_builtin_policy(). */
219 /* Load built-in policy. */
220 tomoyo_write_transition_control("/sbin/hotplug", false,
221 TOMOYO_TRANSITION_CONTROL_INITIALIZE);
222 tomoyo_write_transition_control("/sbin/modprobe", false,
223 TOMOYO_TRANSITION_CONTROL_INITIALIZE);
226 tomoyo_read_unlock(idx);
230 /* Memory allocated for query lists. */
231 unsigned int tomoyo_query_memory_size;
232 /* Quota for holding query lists. */
233 unsigned int tomoyo_quota_for_query;
236 * tomoyo_read_memory_counter - Check for memory usage in bytes.
238 * @head: Pointer to "struct tomoyo_io_buffer".
240 * Returns memory usage.
242 void tomoyo_read_memory_counter(struct tomoyo_io_buffer *head)
245 const unsigned int policy
246 = atomic_read(&tomoyo_policy_memory_size);
247 const unsigned int query = tomoyo_query_memory_size;
250 memset(buffer, 0, sizeof(buffer));
251 if (tomoyo_quota_for_policy)
252 snprintf(buffer, sizeof(buffer) - 1,
254 tomoyo_quota_for_policy);
257 tomoyo_io_printf(head, "Policy: %10u%s\n", policy,
259 if (tomoyo_quota_for_query)
260 snprintf(buffer, sizeof(buffer) - 1,
262 tomoyo_quota_for_query);
265 tomoyo_io_printf(head, "Query lists: %10u%s\n", query,
267 tomoyo_io_printf(head, "Total: %10u\n", policy + query);
273 * tomoyo_write_memory_quota - Set memory quota.
275 * @head: Pointer to "struct tomoyo_io_buffer".
279 int tomoyo_write_memory_quota(struct tomoyo_io_buffer *head)
281 char *data = head->write_buf;
284 if (sscanf(data, "Policy: %u", &size) == 1)
285 tomoyo_quota_for_policy = size;
286 else if (sscanf(data, "Query lists: %u", &size) == 1)
287 tomoyo_quota_for_query = size;