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); 210