xref: /linux/kernel/exec_domain.c (revision 14b42963f64b98ab61fa9723c03d71aa5ef4f862)
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);
210