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