fsldma: simplify IRQ probing and handling
[linux-3.10.git] / security / tomoyo / realpath.c
1 /*
2  * security/tomoyo/realpath.c
3  *
4  * Get the canonicalized absolute pathnames. The basis for TOMOYO.
5  *
6  * Copyright (C) 2005-2009  NTT DATA CORPORATION
7  *
8  * Version: 2.2.0   2009/04/01
9  *
10  */
11
12 #include <linux/types.h>
13 #include <linux/mount.h>
14 #include <linux/mnt_namespace.h>
15 #include <linux/fs_struct.h>
16 #include <linux/hash.h>
17
18 #include "common.h"
19 #include "realpath.h"
20
21 /**
22  * tomoyo_encode: Convert binary string to ascii string.
23  *
24  * @buffer:  Buffer for ASCII string.
25  * @buflen:  Size of @buffer.
26  * @str:     Binary string.
27  *
28  * Returns 0 on success, -ENOMEM otherwise.
29  */
30 int tomoyo_encode(char *buffer, int buflen, const char *str)
31 {
32         while (1) {
33                 const unsigned char c = *(unsigned char *) str++;
34
35                 if (tomoyo_is_valid(c)) {
36                         if (--buflen <= 0)
37                                 break;
38                         *buffer++ = (char) c;
39                         if (c != '\\')
40                                 continue;
41                         if (--buflen <= 0)
42                                 break;
43                         *buffer++ = (char) c;
44                         continue;
45                 }
46                 if (!c) {
47                         if (--buflen <= 0)
48                                 break;
49                         *buffer = '\0';
50                         return 0;
51                 }
52                 buflen -= 4;
53                 if (buflen <= 0)
54                         break;
55                 *buffer++ = '\\';
56                 *buffer++ = (c >> 6) + '0';
57                 *buffer++ = ((c >> 3) & 7) + '0';
58                 *buffer++ = (c & 7) + '0';
59         }
60         return -ENOMEM;
61 }
62
63 /**
64  * tomoyo_realpath_from_path2 - Returns realpath(3) of the given dentry but ignores chroot'ed root.
65  *
66  * @path:        Pointer to "struct path".
67  * @newname:     Pointer to buffer to return value in.
68  * @newname_len: Size of @newname.
69  *
70  * Returns 0 on success, negative value otherwise.
71  *
72  * If dentry is a directory, trailing '/' is appended.
73  * Characters out of 0x20 < c < 0x7F range are converted to
74  * \ooo style octal string.
75  * Character \ is converted to \\ string.
76  */
77 int tomoyo_realpath_from_path2(struct path *path, char *newname,
78                                int newname_len)
79 {
80         int error = -ENOMEM;
81         struct dentry *dentry = path->dentry;
82         char *sp;
83
84         if (!dentry || !path->mnt || !newname || newname_len <= 2048)
85                 return -EINVAL;
86         if (dentry->d_op && dentry->d_op->d_dname) {
87                 /* For "socket:[\$]" and "pipe:[\$]". */
88                 static const int offset = 1536;
89                 sp = dentry->d_op->d_dname(dentry, newname + offset,
90                                            newname_len - offset);
91         } else {
92                 /* Taken from d_namespace_path(). */
93                 struct path root;
94                 struct path ns_root = { };
95                 struct path tmp;
96
97                 read_lock(&current->fs->lock);
98                 root = current->fs->root;
99                 path_get(&root);
100                 read_unlock(&current->fs->lock);
101                 spin_lock(&vfsmount_lock);
102                 if (root.mnt && root.mnt->mnt_ns)
103                         ns_root.mnt = mntget(root.mnt->mnt_ns->root);
104                 if (ns_root.mnt)
105                         ns_root.dentry = dget(ns_root.mnt->mnt_root);
106                 spin_unlock(&vfsmount_lock);
107                 spin_lock(&dcache_lock);
108                 tmp = ns_root;
109                 sp = __d_path(path, &tmp, newname, newname_len);
110                 spin_unlock(&dcache_lock);
111                 path_put(&root);
112                 path_put(&ns_root);
113                 /* Prepend "/proc" prefix if using internal proc vfs mount. */
114                 if (!IS_ERR(sp) && (path->mnt->mnt_parent == path->mnt) &&
115                     (strcmp(path->mnt->mnt_sb->s_type->name, "proc") == 0)) {
116                         sp -= 5;
117                         if (sp >= newname)
118                                 memcpy(sp, "/proc", 5);
119                         else
120                                 sp = ERR_PTR(-ENOMEM);
121                 }
122         }
123         if (IS_ERR(sp))
124                 error = PTR_ERR(sp);
125         else
126                 error = tomoyo_encode(newname, sp - newname, sp);
127         /* Append trailing '/' if dentry is a directory. */
128         if (!error && dentry->d_inode && S_ISDIR(dentry->d_inode->i_mode)
129             && *newname) {
130                 sp = newname + strlen(newname);
131                 if (*(sp - 1) != '/') {
132                         if (sp < newname + newname_len - 4) {
133                                 *sp++ = '/';
134                                 *sp = '\0';
135                         } else {
136                                 error = -ENOMEM;
137                         }
138                 }
139         }
140         if (error)
141                 printk(KERN_WARNING "tomoyo_realpath: Pathname too long.\n");
142         return error;
143 }
144
145 /**
146  * tomoyo_realpath_from_path - Returns realpath(3) of the given pathname but ignores chroot'ed root.
147  *
148  * @path: Pointer to "struct path".
149  *
150  * Returns the realpath of the given @path on success, NULL otherwise.
151  *
152  * These functions use tomoyo_alloc(), so the caller must call tomoyo_free()
153  * if these functions didn't return NULL.
154  */
155 char *tomoyo_realpath_from_path(struct path *path)
156 {
157         char *buf = tomoyo_alloc(sizeof(struct tomoyo_page_buffer));
158
159         BUILD_BUG_ON(sizeof(struct tomoyo_page_buffer)
160                      <= TOMOYO_MAX_PATHNAME_LEN - 1);
161         if (!buf)
162                 return NULL;
163         if (tomoyo_realpath_from_path2(path, buf,
164                                        TOMOYO_MAX_PATHNAME_LEN - 1) == 0)
165                 return buf;
166         tomoyo_free(buf);
167         return NULL;
168 }
169
170 /**
171  * tomoyo_realpath - Get realpath of a pathname.
172  *
173  * @pathname: The pathname to solve.
174  *
175  * Returns the realpath of @pathname on success, NULL otherwise.
176  */
177 char *tomoyo_realpath(const char *pathname)
178 {
179         struct path path;
180
181         if (pathname && kern_path(pathname, LOOKUP_FOLLOW, &path) == 0) {
182                 char *buf = tomoyo_realpath_from_path(&path);
183                 path_put(&path);
184                 return buf;
185         }
186         return NULL;
187 }
188
189 /**
190  * tomoyo_realpath_nofollow - Get realpath of a pathname.
191  *
192  * @pathname: The pathname to solve.
193  *
194  * Returns the realpath of @pathname on success, NULL otherwise.
195  */
196 char *tomoyo_realpath_nofollow(const char *pathname)
197 {
198         struct path path;
199
200         if (pathname && kern_path(pathname, 0, &path) == 0) {
201                 char *buf = tomoyo_realpath_from_path(&path);
202                 path_put(&path);
203                 return buf;
204         }
205         return NULL;
206 }
207
208 /* Memory allocated for non-string data. */
209 static unsigned int tomoyo_allocated_memory_for_elements;
210 /* Quota for holding non-string data. */
211 static unsigned int tomoyo_quota_for_elements;
212
213 /**
214  * tomoyo_alloc_element - Allocate permanent memory for structures.
215  *
216  * @size: Size in bytes.
217  *
218  * Returns pointer to allocated memory on success, NULL otherwise.
219  *
220  * Memory has to be zeroed.
221  * The RAM is chunked, so NEVER try to kfree() the returned pointer.
222  */
223 void *tomoyo_alloc_element(const unsigned int size)
224 {
225         static char *buf;
226         static DEFINE_MUTEX(lock);
227         static unsigned int buf_used_len = PATH_MAX;
228         char *ptr = NULL;
229         /*Assumes sizeof(void *) >= sizeof(long) is true. */
230         const unsigned int word_aligned_size
231                 = roundup(size, max(sizeof(void *), sizeof(long)));
232         if (word_aligned_size > PATH_MAX)
233                 return NULL;
234         mutex_lock(&lock);
235         if (buf_used_len + word_aligned_size > PATH_MAX) {
236                 if (!tomoyo_quota_for_elements ||
237                     tomoyo_allocated_memory_for_elements
238                     + PATH_MAX <= tomoyo_quota_for_elements)
239                         ptr = kzalloc(PATH_MAX, GFP_KERNEL);
240                 if (!ptr) {
241                         printk(KERN_WARNING "ERROR: Out of memory "
242                                "for tomoyo_alloc_element().\n");
243                         if (!tomoyo_policy_loaded)
244                                 panic("MAC Initialization failed.\n");
245                 } else {
246                         buf = ptr;
247                         tomoyo_allocated_memory_for_elements += PATH_MAX;
248                         buf_used_len = word_aligned_size;
249                         ptr = buf;
250                 }
251         } else if (word_aligned_size) {
252                 int i;
253                 ptr = buf + buf_used_len;
254                 buf_used_len += word_aligned_size;
255                 for (i = 0; i < word_aligned_size; i++) {
256                         if (!ptr[i])
257                                 continue;
258                         printk(KERN_ERR "WARNING: Reserved memory was tainted! "
259                                "The system might go wrong.\n");
260                         ptr[i] = '\0';
261                 }
262         }
263         mutex_unlock(&lock);
264         return ptr;
265 }
266
267 /* Memory allocated for string data in bytes. */
268 static unsigned int tomoyo_allocated_memory_for_savename;
269 /* Quota for holding string data in bytes. */
270 static unsigned int tomoyo_quota_for_savename;
271
272 /*
273  * TOMOYO uses this hash only when appending a string into the string
274  * table. Frequency of appending strings is very low. So we don't need
275  * large (e.g. 64k) hash size. 256 will be sufficient.
276  */
277 #define TOMOYO_HASH_BITS  8
278 #define TOMOYO_MAX_HASH (1u<<TOMOYO_HASH_BITS)
279
280 /*
281  * tomoyo_name_entry is a structure which is used for linking
282  * "struct tomoyo_path_info" into tomoyo_name_list .
283  *
284  * Since tomoyo_name_list manages a list of strings which are shared by
285  * multiple processes (whereas "struct tomoyo_path_info" inside
286  * "struct tomoyo_path_info_with_data" is not shared), a reference counter will
287  * be added to "struct tomoyo_name_entry" rather than "struct tomoyo_path_info"
288  * when TOMOYO starts supporting garbage collector.
289  */
290 struct tomoyo_name_entry {
291         struct list_head list;
292         struct tomoyo_path_info entry;
293 };
294
295 /* Structure for available memory region. */
296 struct tomoyo_free_memory_block_list {
297         struct list_head list;
298         char *ptr;             /* Pointer to a free area. */
299         int len;               /* Length of the area.     */
300 };
301
302 /*
303  * tomoyo_name_list is used for holding string data used by TOMOYO.
304  * Since same string data is likely used for multiple times (e.g.
305  * "/lib/libc-2.5.so"), TOMOYO shares string data in the form of
306  * "const struct tomoyo_path_info *".
307  */
308 static struct list_head tomoyo_name_list[TOMOYO_MAX_HASH];
309
310 /**
311  * tomoyo_save_name - Allocate permanent memory for string data.
312  *
313  * @name: The string to store into the permernent memory.
314  *
315  * Returns pointer to "struct tomoyo_path_info" on success, NULL otherwise.
316  *
317  * The RAM is shared, so NEVER try to modify or kfree() the returned name.
318  */
319 const struct tomoyo_path_info *tomoyo_save_name(const char *name)
320 {
321         static LIST_HEAD(fmb_list);
322         static DEFINE_MUTEX(lock);
323         struct tomoyo_name_entry *ptr;
324         unsigned int hash;
325         /* fmb contains available size in bytes.
326            fmb is removed from the fmb_list when fmb->len becomes 0. */
327         struct tomoyo_free_memory_block_list *fmb;
328         int len;
329         char *cp;
330         struct list_head *head;
331
332         if (!name)
333                 return NULL;
334         len = strlen(name) + 1;
335         if (len > TOMOYO_MAX_PATHNAME_LEN) {
336                 printk(KERN_WARNING "ERROR: Name too long "
337                        "for tomoyo_save_name().\n");
338                 return NULL;
339         }
340         hash = full_name_hash((const unsigned char *) name, len - 1);
341         head = &tomoyo_name_list[hash_long(hash, TOMOYO_HASH_BITS)];
342
343         mutex_lock(&lock);
344         list_for_each_entry(ptr, head, list) {
345                 if (hash == ptr->entry.hash && !strcmp(name, ptr->entry.name))
346                         goto out;
347         }
348         list_for_each_entry(fmb, &fmb_list, list) {
349                 if (len <= fmb->len)
350                         goto ready;
351         }
352         if (!tomoyo_quota_for_savename ||
353             tomoyo_allocated_memory_for_savename + PATH_MAX
354             <= tomoyo_quota_for_savename)
355                 cp = kzalloc(PATH_MAX, GFP_KERNEL);
356         else
357                 cp = NULL;
358         fmb = kzalloc(sizeof(*fmb), GFP_KERNEL);
359         if (!cp || !fmb) {
360                 kfree(cp);
361                 kfree(fmb);
362                 printk(KERN_WARNING "ERROR: Out of memory "
363                        "for tomoyo_save_name().\n");
364                 if (!tomoyo_policy_loaded)
365                         panic("MAC Initialization failed.\n");
366                 ptr = NULL;
367                 goto out;
368         }
369         tomoyo_allocated_memory_for_savename += PATH_MAX;
370         list_add(&fmb->list, &fmb_list);
371         fmb->ptr = cp;
372         fmb->len = PATH_MAX;
373  ready:
374         ptr = tomoyo_alloc_element(sizeof(*ptr));
375         if (!ptr)
376                 goto out;
377         ptr->entry.name = fmb->ptr;
378         memmove(fmb->ptr, name, len);
379         tomoyo_fill_path_info(&ptr->entry);
380         fmb->ptr += len;
381         fmb->len -= len;
382         list_add_tail(&ptr->list, head);
383         if (fmb->len == 0) {
384                 list_del(&fmb->list);
385                 kfree(fmb);
386         }
387  out:
388         mutex_unlock(&lock);
389         return ptr ? &ptr->entry : NULL;
390 }
391
392 /**
393  * tomoyo_realpath_init - Initialize realpath related code.
394  */
395 void __init tomoyo_realpath_init(void)
396 {
397         int i;
398
399         BUILD_BUG_ON(TOMOYO_MAX_PATHNAME_LEN > PATH_MAX);
400         for (i = 0; i < TOMOYO_MAX_HASH; i++)
401                 INIT_LIST_HEAD(&tomoyo_name_list[i]);
402         INIT_LIST_HEAD(&tomoyo_kernel_domain.acl_info_list);
403         tomoyo_kernel_domain.domainname = tomoyo_save_name(TOMOYO_ROOT_NAME);
404         list_add_tail(&tomoyo_kernel_domain.list, &tomoyo_domain_list);
405         down_read(&tomoyo_domain_list_lock);
406         if (tomoyo_find_domain(TOMOYO_ROOT_NAME) != &tomoyo_kernel_domain)
407                 panic("Can't register tomoyo_kernel_domain");
408         up_read(&tomoyo_domain_list_lock);
409 }
410
411 /* Memory allocated for temporary purpose. */
412 static atomic_t tomoyo_dynamic_memory_size;
413
414 /**
415  * tomoyo_alloc - Allocate memory for temporary purpose.
416  *
417  * @size: Size in bytes.
418  *
419  * Returns pointer to allocated memory on success, NULL otherwise.
420  */
421 void *tomoyo_alloc(const size_t size)
422 {
423         void *p = kzalloc(size, GFP_KERNEL);
424         if (p)
425                 atomic_add(ksize(p), &tomoyo_dynamic_memory_size);
426         return p;
427 }
428
429 /**
430  * tomoyo_free - Release memory allocated by tomoyo_alloc().
431  *
432  * @p: Pointer returned by tomoyo_alloc(). May be NULL.
433  *
434  * Returns nothing.
435  */
436 void tomoyo_free(const void *p)
437 {
438         if (p) {
439                 atomic_sub(ksize(p), &tomoyo_dynamic_memory_size);
440                 kfree(p);
441         }
442 }
443
444 /**
445  * tomoyo_read_memory_counter - Check for memory usage in bytes.
446  *
447  * @head: Pointer to "struct tomoyo_io_buffer".
448  *
449  * Returns memory usage.
450  */
451 int tomoyo_read_memory_counter(struct tomoyo_io_buffer *head)
452 {
453         if (!head->read_eof) {
454                 const unsigned int shared
455                         = tomoyo_allocated_memory_for_savename;
456                 const unsigned int private
457                         = tomoyo_allocated_memory_for_elements;
458                 const unsigned int dynamic
459                         = atomic_read(&tomoyo_dynamic_memory_size);
460                 char buffer[64];
461
462                 memset(buffer, 0, sizeof(buffer));
463                 if (tomoyo_quota_for_savename)
464                         snprintf(buffer, sizeof(buffer) - 1,
465                                  "   (Quota: %10u)",
466                                  tomoyo_quota_for_savename);
467                 else
468                         buffer[0] = '\0';
469                 tomoyo_io_printf(head, "Shared:  %10u%s\n", shared, buffer);
470                 if (tomoyo_quota_for_elements)
471                         snprintf(buffer, sizeof(buffer) - 1,
472                                  "   (Quota: %10u)",
473                                  tomoyo_quota_for_elements);
474                 else
475                         buffer[0] = '\0';
476                 tomoyo_io_printf(head, "Private: %10u%s\n", private, buffer);
477                 tomoyo_io_printf(head, "Dynamic: %10u\n", dynamic);
478                 tomoyo_io_printf(head, "Total:   %10u\n",
479                                  shared + private + dynamic);
480                 head->read_eof = true;
481         }
482         return 0;
483 }
484
485 /**
486  * tomoyo_write_memory_quota - Set memory quota.
487  *
488  * @head: Pointer to "struct tomoyo_io_buffer".
489  *
490  * Returns 0.
491  */
492 int tomoyo_write_memory_quota(struct tomoyo_io_buffer *head)
493 {
494         char *data = head->write_buf;
495         unsigned int size;
496
497         if (sscanf(data, "Shared: %u", &size) == 1)
498                 tomoyo_quota_for_savename = size;
499         else if (sscanf(data, "Private: %u", &size) == 1)
500                 tomoyo_quota_for_elements = size;
501         return 0;
502 }