Branch data Line data Source code
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 : : #include <linux/fs_struct.h>
22 : :
23 : :
24 : : static void default_handler(int, struct pt_regs *);
25 : :
26 : : static struct exec_domain *exec_domains = &default_exec_domain;
27 : : static DEFINE_RWLOCK(exec_domains_lock);
28 : :
29 : :
30 : : static unsigned long ident_map[32] = {
31 : : 0, 1, 2, 3, 4, 5, 6, 7,
32 : : 8, 9, 10, 11, 12, 13, 14, 15,
33 : : 16, 17, 18, 19, 20, 21, 22, 23,
34 : : 24, 25, 26, 27, 28, 29, 30, 31
35 : : };
36 : :
37 : : struct exec_domain default_exec_domain = {
38 : : .name = "Linux", /* name */
39 : : .handler = default_handler, /* lcall7 causes a seg fault. */
40 : : .pers_low = 0, /* PER_LINUX personality. */
41 : : .pers_high = 0, /* PER_LINUX personality. */
42 : : .signal_map = ident_map, /* Identity map signals. */
43 : : .signal_invmap = ident_map, /* - both ways. */
44 : : };
45 : :
46 : :
47 : : static void
48 : 0 : default_handler(int segment, struct pt_regs *regp)
49 : : {
50 [ # # ]: 0 : set_personality(0);
51 : :
52 [ # # ]: 0 : if (current_thread_info()->exec_domain->handler != default_handler)
53 : 0 : current_thread_info()->exec_domain->handler(segment, regp);
54 : : else
55 : 0 : send_sig(SIGSEGV, current, 1);
56 : 0 : }
57 : :
58 : : static struct exec_domain *
59 : 0 : lookup_exec_domain(unsigned int personality)
60 : : {
61 : 24 : unsigned int pers = personality(personality);
62 : : struct exec_domain *ep;
63 : :
64 : 24 : read_lock(&exec_domains_lock);
65 [ + - ]: 24 : for (ep = exec_domains; ep; ep = ep->next) {
66 [ + - ][ + - ]: 24 : if (pers >= ep->pers_low && pers <= ep->pers_high)
67 [ - + ]: 24 : if (try_module_get(ep->module))
68 : : goto out;
69 : : }
70 : :
71 : : #ifdef CONFIG_MODULES
72 : : read_unlock(&exec_domains_lock);
73 : 0 : request_module("personality-%d", pers);
74 : 0 : read_lock(&exec_domains_lock);
75 : :
76 [ # # ]: 0 : for (ep = exec_domains; ep; ep = ep->next) {
77 [ # # ][ # # ]: 0 : if (pers >= ep->pers_low && pers <= ep->pers_high)
78 [ # # ]: 0 : if (try_module_get(ep->module))
79 : : goto out;
80 : : }
81 : : #endif
82 : :
83 : : ep = &default_exec_domain;
84 : : out:
85 : : read_unlock(&exec_domains_lock);
86 : 24 : return (ep);
87 : : }
88 : :
89 : : int
90 : 0 : register_exec_domain(struct exec_domain *ep)
91 : : {
92 : : struct exec_domain *tmp;
93 : : int err = -EBUSY;
94 : :
95 [ # # ]: 0 : if (ep == NULL)
96 : : return -EINVAL;
97 : :
98 [ # # ]: 0 : if (ep->next != NULL)
99 : : return -EBUSY;
100 : :
101 : 0 : write_lock(&exec_domains_lock);
102 [ # # ]: 0 : for (tmp = exec_domains; tmp; tmp = tmp->next) {
103 [ # # ]: 0 : if (tmp == ep)
104 : : goto out;
105 : : }
106 : :
107 : 0 : ep->next = exec_domains;
108 : 0 : exec_domains = ep;
109 : : err = 0;
110 : :
111 : : out:
112 : : write_unlock(&exec_domains_lock);
113 : 0 : return (err);
114 : : }
115 : :
116 : : int
117 : 0 : unregister_exec_domain(struct exec_domain *ep)
118 : : {
119 : : struct exec_domain **epp;
120 : :
121 : : epp = &exec_domains;
122 : 0 : write_lock(&exec_domains_lock);
123 [ # # ]: 0 : for (epp = &exec_domains; *epp; epp = &(*epp)->next) {
124 [ # # ]: 0 : if (ep == *epp)
125 : : goto unregister;
126 : : }
127 : : write_unlock(&exec_domains_lock);
128 : 0 : return -EINVAL;
129 : :
130 : : unregister:
131 : 0 : *epp = ep->next;
132 : 0 : ep->next = NULL;
133 : : write_unlock(&exec_domains_lock);
134 : 0 : return 0;
135 : : }
136 : :
137 : 0 : int __set_personality(unsigned int personality)
138 : : {
139 : 24 : struct exec_domain *oep = current_thread_info()->exec_domain;
140 : :
141 : 24 : current_thread_info()->exec_domain = lookup_exec_domain(personality);
142 : 24 : current->personality = personality;
143 : 24 : module_put(oep->module);
144 : :
145 : 24 : return 0;
146 : : }
147 : :
148 : : #ifdef CONFIG_PROC_FS
149 : 0 : static int execdomains_proc_show(struct seq_file *m, void *v)
150 : : {
151 : : struct exec_domain *ep;
152 : :
153 : 1 : read_lock(&exec_domains_lock);
154 [ + + ]: 2 : for (ep = exec_domains; ep; ep = ep->next)
155 : 1 : seq_printf(m, "%d-%d\t%-16s\t[%s]\n",
156 : 2 : ep->pers_low, ep->pers_high, ep->name,
157 [ - + ]: 1 : module_name(ep->module));
158 : : read_unlock(&exec_domains_lock);
159 : 1 : return 0;
160 : : }
161 : :
162 : 0 : static int execdomains_proc_open(struct inode *inode, struct file *file)
163 : : {
164 : 1 : return single_open(file, execdomains_proc_show, NULL);
165 : : }
166 : :
167 : : static const struct file_operations execdomains_proc_fops = {
168 : : .open = execdomains_proc_open,
169 : : .read = seq_read,
170 : : .llseek = seq_lseek,
171 : : .release = single_release,
172 : : };
173 : :
174 : 0 : static int __init proc_execdomains_init(void)
175 : : {
176 : : proc_create("execdomains", 0, NULL, &execdomains_proc_fops);
177 : 0 : return 0;
178 : : }
179 : : module_init(proc_execdomains_init);
180 : : #endif
181 : :
182 : 0 : SYSCALL_DEFINE1(personality, unsigned int, personality)
183 : : {
184 : 0 : unsigned int old = current->personality;
185 : :
186 [ # # ]: 0 : if (personality != 0xffffffff)
187 [ # # ]: 0 : set_personality(personality);
188 : :
189 : 0 : return old;
190 : : }
191 : :
192 : :
193 : : EXPORT_SYMBOL(register_exec_domain);
194 : : EXPORT_SYMBOL(unregister_exec_domain);
195 : : EXPORT_SYMBOL(__set_personality);
|
