Contents of /alx-src/tags/kernel26-2.6.12-alx-r9/kernel/exec_domain.c
Parent Directory | Revision Log
Revision 630 -
(show annotations)
(download)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 4450 byte(s)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 4450 byte(s)
Tag kernel26-2.6.12-alx-r9
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 | return 0; |
144 | } |
145 | |
146 | if (atomic_read(¤t->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); |