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