[PATCH] Fix module refcount leak in __set_personality()
[linux-2.6.git] / kernel / exec_domain.c
1 /*
2  * Handling of different ABIs (personalities).
3  *
4  * We group personalities into execution domains which have their
5  * own handlers for kernel entry points, signal mapping, etc...
6  *
7  * 2001-05-06   Complete rewrite,  Christoph Hellwig (hch@infradead.org)
8  */
9
10 #include <linux/config.h>
11 #include <linux/init.h>
12 #include <linux/kernel.h>
13 #include <linux/kmod.h>
14 #include <linux/module.h>
15 #include <linux/personality.h>
16 #include <linux/sched.h>
17 #include <linux/syscalls.h>
18 #include <linux/sysctl.h>
19 #include <linux/types.h>
20
21
22 static void default_handler(int, struct pt_regs *);
23
24 static struct exec_domain *exec_domains = &default_exec_domain;
25 static DEFINE_RWLOCK(exec_domains_lock);
26
27
28 static u_long ident_map[32] = {
29         0,      1,      2,      3,      4,      5,      6,      7,
30         8,      9,      10,     11,     12,     13,     14,     15,
31         16,     17,     18,     19,     20,     21,     22,     23,
32         24,     25,     26,     27,     28,     29,     30,     31
33 };
34
35 struct exec_domain default_exec_domain = {
36         .name           = "Linux",              /* name */
37         .handler        = default_handler,      /* lcall7 causes a seg fault. */
38         .pers_low       = 0,                    /* PER_LINUX personality. */
39         .pers_high      = 0,                    /* PER_LINUX personality. */
40         .signal_map     = ident_map,            /* Identity map signals. */
41         .signal_invmap  = ident_map,            /*  - both ways. */
42 };
43
44
45 static void
46 default_handler(int segment, struct pt_regs *regp)
47 {
48         set_personality(0);
49
50         if (current_thread_info()->exec_domain->handler != default_handler)
51                 current_thread_info()->exec_domain->handler(segment, regp);
52         else
53                 send_sig(SIGSEGV, current, 1);
54 }
55
56 static struct exec_domain *
57 lookup_exec_domain(u_long personality)
58 {
59         struct exec_domain *    ep;
60         u_long                  pers = personality(personality);
61                 
62         read_lock(&exec_domains_lock);
63         for (ep = exec_domains; ep; ep = ep->next) {
64                 if (pers >= ep->pers_low && pers <= ep->pers_high)
65                         if (try_module_get(ep->module))
66                                 goto out;
67         }
68
69 #ifdef CONFIG_KMOD
70         read_unlock(&exec_domains_lock);
71         request_module("personality-%ld", pers);
72         read_lock(&exec_domains_lock);
73
74         for (ep = exec_domains; ep; ep = ep->next) {
75                 if (pers >= ep->pers_low && pers <= ep->pers_high)
76                         if (try_module_get(ep->module))
77                                 goto out;
78         }
79 #endif
80
81         ep = &default_exec_domain;
82 out:
83         read_unlock(&exec_domains_lock);
84         return (ep);
85 }
86
87 int
88 register_exec_domain(struct exec_domain *ep)
89 {
90         struct exec_domain      *tmp;
91         int                     err = -EBUSY;
92
93         if (ep == NULL)
94                 return -EINVAL;
95
96         if (ep->next != NULL)
97                 return -EBUSY;
98
99         write_lock(&exec_domains_lock);
100         for (tmp = exec_domains; tmp; tmp = tmp->next) {
101                 if (tmp == ep)
102                         goto out;
103         }
104
105         ep->next = exec_domains;
106         exec_domains = ep;
107         err = 0;
108
109 out:
110         write_unlock(&exec_domains_lock);
111         return (err);
112 }
113
114 int
115 unregister_exec_domain(struct exec_domain *ep)
116 {
117         struct exec_domain      **epp;
118
119         epp = &exec_domains;
120         write_lock(&exec_domains_lock);
121         for (epp = &exec_domains; *epp; epp = &(*epp)->next) {
122                 if (ep == *epp)
123                         goto unregister;
124         }
125         write_unlock(&exec_domains_lock);
126         return -EINVAL;
127
128 unregister:
129         *epp = ep->next;
130         ep->next = NULL;
131         write_unlock(&exec_domains_lock);
132         return 0;
133 }
134
135 int
136 __set_personality(u_long personality)
137 {
138         struct exec_domain      *ep, *oep;
139
140         ep = lookup_exec_domain(personality);
141         if (ep == current_thread_info()->exec_domain) {
142                 current->personality = personality;
143                 module_put(ep->module);
144                 return 0;
145         }
146
147         if (atomic_read(&current->fs->count) != 1) {
148                 struct fs_struct *fsp, *ofsp;
149
150                 fsp = copy_fs_struct(current->fs);
151                 if (fsp == NULL) {
152                         module_put(ep->module);
153                         return -ENOMEM;
154                 }
155
156                 task_lock(current);
157                 ofsp = current->fs;
158                 current->fs = fsp;
159                 task_unlock(current);
160
161                 put_fs_struct(ofsp);
162         }
163
164         /*
165          * At that point we are guaranteed to be the sole owner of
166          * current->fs.
167          */
168
169         current->personality = personality;
170         oep = current_thread_info()->exec_domain;
171         current_thread_info()->exec_domain = ep;
172         set_fs_altroot();
173
174         module_put(oep->module);
175         return 0;
176 }
177
178 int
179 get_exec_domain_list(char *page)
180 {
181         struct exec_domain      *ep;
182         int                     len = 0;
183
184         read_lock(&exec_domains_lock);
185         for (ep = exec_domains; ep && len < PAGE_SIZE - 80; ep = ep->next)
186                 len += sprintf(page + len, "%d-%d\t%-16s\t[%s]\n",
187                                ep->pers_low, ep->pers_high, ep->name,
188                                module_name(ep->module));
189         read_unlock(&exec_domains_lock);
190         return (len);
191 }
192
193 asmlinkage long
194 sys_personality(u_long personality)
195 {
196         u_long old = current->personality;
197
198         if (personality != 0xffffffff) {
199                 set_personality(personality);
200                 if (current->personality != personality)
201                         return -EINVAL;
202         }
203
204         return (long)old;
205 }
206
207
208 EXPORT_SYMBOL(register_exec_domain);
209 EXPORT_SYMBOL(unregister_exec_domain);
210 EXPORT_SYMBOL(__set_personality);