fa592ff1ac1c4f7b24394baf6a2155dc1fb911a6
[linux-3.10.git] / security / integrity / ima / ima_iint.c
1 /*
2  * Copyright (C) 2008 IBM Corporation
3  *
4  * Authors:
5  * Mimi Zohar <zohar@us.ibm.com>
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License as
9  * published by the Free Software Foundation, version 2 of the
10  * License.
11  *
12  * File: ima_iint.c
13  *      - implements the IMA hooks: ima_inode_alloc, ima_inode_free
14  *      - cache integrity information associated with an inode
15  *        using a radix tree.
16  */
17 #include <linux/module.h>
18 #include <linux/spinlock.h>
19 #include <linux/radix-tree.h>
20 #include "ima.h"
21
22 RADIX_TREE(ima_iint_store, GFP_ATOMIC);
23 DEFINE_SPINLOCK(ima_iint_lock);
24
25 static struct kmem_cache *iint_cache __read_mostly;
26
27 /* ima_iint_find_get - return the iint associated with an inode
28  *
29  * ima_iint_find_get gets a reference to the iint. Caller must
30  * remember to put the iint reference.
31  */
32 struct ima_iint_cache *ima_iint_find_get(struct inode *inode)
33 {
34         struct ima_iint_cache *iint;
35
36         rcu_read_lock();
37         iint = radix_tree_lookup(&ima_iint_store, (unsigned long)inode);
38         if (!iint)
39                 goto out;
40         kref_get(&iint->refcount);
41 out:
42         rcu_read_unlock();
43         return iint;
44 }
45
46 /**
47  * ima_inode_alloc - allocate an iint associated with an inode
48  * @inode: pointer to the inode
49  */
50 int ima_inode_alloc(struct inode *inode)
51 {
52         struct ima_iint_cache *iint = NULL;
53         int rc = 0;
54
55         if (!ima_initialized)
56                 return 0;
57
58         iint = kmem_cache_alloc(iint_cache, GFP_NOFS);
59         if (!iint)
60                 return -ENOMEM;
61
62         rc = radix_tree_preload(GFP_NOFS);
63         if (rc < 0)
64                 goto out;
65
66         spin_lock(&ima_iint_lock);
67         rc = radix_tree_insert(&ima_iint_store, (unsigned long)inode, iint);
68         spin_unlock(&ima_iint_lock);
69 out:
70         if (rc < 0)
71                 kmem_cache_free(iint_cache, iint);
72
73         radix_tree_preload_end();
74
75         return rc;
76 }
77
78 /* iint_free - called when the iint refcount goes to zero */
79 void iint_free(struct kref *kref)
80 {
81         struct ima_iint_cache *iint = container_of(kref, struct ima_iint_cache,
82                                                    refcount);
83         iint->version = 0;
84         iint->flags = 0UL;
85         if (iint->readcount != 0) {
86                 printk(KERN_INFO "%s: readcount: %ld\n", __FUNCTION__,
87                        iint->readcount);
88                 iint->readcount = 0;
89         }
90         if (iint->writecount != 0) {
91                 printk(KERN_INFO "%s: writecount: %ld\n", __FUNCTION__,
92                        iint->writecount);
93                 iint->writecount = 0;
94         }
95         if (iint->opencount != 0) {
96                 printk(KERN_INFO "%s: opencount: %ld\n", __FUNCTION__,
97                        iint->opencount);
98                 iint->opencount = 0;
99         }
100         kref_set(&iint->refcount, 1);
101         kmem_cache_free(iint_cache, iint);
102 }
103
104 void iint_rcu_free(struct rcu_head *rcu_head)
105 {
106         struct ima_iint_cache *iint = container_of(rcu_head,
107                                                    struct ima_iint_cache, rcu);
108         kref_put(&iint->refcount, iint_free);
109 }
110
111 /**
112  * ima_inode_free - called on security_inode_free
113  * @inode: pointer to the inode
114  *
115  * Free the integrity information(iint) associated with an inode.
116  */
117 void ima_inode_free(struct inode *inode)
118 {
119         struct ima_iint_cache *iint;
120
121         if (!ima_initialized)
122                 return;
123         spin_lock(&ima_iint_lock);
124         iint = radix_tree_delete(&ima_iint_store, (unsigned long)inode);
125         spin_unlock(&ima_iint_lock);
126         if (iint)
127                 call_rcu(&iint->rcu, iint_rcu_free);
128 }
129
130 static void init_once(void *foo)
131 {
132         struct ima_iint_cache *iint = foo;
133
134         memset(iint, 0, sizeof *iint);
135         iint->version = 0;
136         iint->flags = 0UL;
137         mutex_init(&iint->mutex);
138         iint->readcount = 0;
139         iint->writecount = 0;
140         iint->opencount = 0;
141         kref_set(&iint->refcount, 1);
142 }
143
144 void __init ima_iintcache_init(void)
145 {
146         iint_cache =
147             kmem_cache_create("iint_cache", sizeof(struct ima_iint_cache), 0,
148                               SLAB_PANIC, init_once);
149 }