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(¤t->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);
211
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.