| /* |
| * Handling of different ABIs (personalities). |
| * |
| * We group personalities into execution domains which have their |
| * own handlers for kernel entry points, signal mapping, etc... |
| * |
| * 2001-05-06 Complete rewrite, Christoph Hellwig (hch@infradead.org) |
| */ |
| |
| #include <linux/config.h> |
| #include <linux/init.h> |
| #include <linux/kernel.h> |
| #include <linux/kmod.h> |
| #include <linux/module.h> |
| #include <linux/personality.h> |
| #include <linux/sched.h> |
| #include <linux/sysctl.h> |
| #include <linux/types.h> |
| |
| |
| static void default_handler(int, struct pt_regs *); |
| |
| static struct exec_domain *exec_domains = &default_exec_domain; |
| static rwlock_t exec_domains_lock = RW_LOCK_UNLOCKED; |
| |
| |
| static u_long ident_map[32] = { |
| 0, 1, 2, 3, 4, 5, 6, 7, |
| 8, 9, 10, 11, 12, 13, 14, 15, |
| 16, 17, 18, 19, 20, 21, 22, 23, |
| 24, 25, 26, 27, 28, 29, 30, 31 |
| }; |
| |
| struct exec_domain default_exec_domain = { |
| "Linux", /* name */ |
| default_handler, /* lcall7 causes a seg fault. */ |
| 0, 0, /* PER_LINUX personality. */ |
| ident_map, /* Identity map signals. */ |
| ident_map, /* - both ways. */ |
| }; |
| |
| |
| static void |
| default_handler(int segment, struct pt_regs *regp) |
| { |
| u_long pers = 0; |
| |
| /* |
| * This may have been a static linked SVr4 binary, so we would |
| * have the personality set incorrectly. Or it might have been |
| * a Solaris/x86 binary. We can tell which because the former |
| * uses lcall7, while the latter used lcall 0x27. |
| * Try to find or load the appropriate personality, and fall back |
| * to just forcing a SEGV. |
| * |
| * XXX: this is IA32-specific and should be moved to the MD-tree. |
| */ |
| switch (segment) { |
| #ifdef __i386__ |
| case 0x07: |
| pers = abi_defhandler_lcall7; |
| break; |
| case 0x27: |
| pers = PER_SOLARIS; |
| break; |
| #endif |
| } |
| set_personality(pers); |
| |
| if (current_thread_info()->exec_domain->handler != default_handler) |
| current_thread_info()->exec_domain->handler(segment, regp); |
| else |
| send_sig(SIGSEGV, current, 1); |
| } |
| |
| static struct exec_domain * |
| lookup_exec_domain(u_long personality) |
| { |
| struct exec_domain * ep; |
| u_long pers = personality(personality); |
| |
| read_lock(&exec_domains_lock); |
| for (ep = exec_domains; ep; ep = ep->next) { |
| if (pers >= ep->pers_low && pers <= ep->pers_high) |
| if (try_inc_mod_count(ep->module)) |
| goto out; |
| } |
| |
| #ifdef CONFIG_KMOD |
| read_unlock(&exec_domains_lock); |
| { |
| char buffer[30]; |
| sprintf(buffer, "personality-%ld", pers); |
| request_module(buffer); |
| } |
| read_lock(&exec_domains_lock); |
| |
| for (ep = exec_domains; ep; ep = ep->next) { |
| if (pers >= ep->pers_low && pers <= ep->pers_high) |
| if (try_inc_mod_count(ep->module)) |
| goto out; |
| } |
| #endif |
| |
| ep = &default_exec_domain; |
| out: |
| read_unlock(&exec_domains_lock); |
| return (ep); |
| } |
| |
| int |
| register_exec_domain(struct exec_domain *ep) |
| { |
| struct exec_domain *tmp; |
| int err = -EBUSY; |
| |
| if (ep == NULL) |
| return -EINVAL; |
| |
| if (ep->next != NULL) |
| return -EBUSY; |
| |
| write_lock(&exec_domains_lock); |
| for (tmp = exec_domains; tmp; tmp = tmp->next) { |
| if (tmp == ep) |
| goto out; |
| } |
| |
| ep->next = exec_domains; |
| exec_domains = ep; |
| err = 0; |
| |
| out: |
| write_unlock(&exec_domains_lock); |
| return (err); |
| } |
| |
| int |
| unregister_exec_domain(struct exec_domain *ep) |
| { |
| struct exec_domain **epp; |
| |
| epp = &exec_domains; |
| write_lock(&exec_domains_lock); |
| for (epp = &exec_domains; *epp; epp = &(*epp)->next) { |
| if (ep == *epp) |
| goto unregister; |
| } |
| write_unlock(&exec_domains_lock); |
| return -EINVAL; |
| |
| unregister: |
| *epp = ep->next; |
| ep->next = NULL; |
| write_unlock(&exec_domains_lock); |
| return 0; |
| } |
| |
| int |
| __set_personality(u_long personality) |
| { |
| struct exec_domain *ep, *oep; |
| |
| ep = lookup_exec_domain(personality); |
| if (ep == current_thread_info()->exec_domain) { |
| current->personality = personality; |
| return 0; |
| } |
| |
| if (atomic_read(¤t->fs->count) != 1) { |
| struct fs_struct *fsp, *ofsp; |
| |
| fsp = copy_fs_struct(current->fs); |
| if (fsp == NULL) { |
| put_exec_domain(ep); |
| return -ENOMEM;; |
| } |
| |
| task_lock(current); |
| ofsp = current->fs; |
| current->fs = fsp; |
| task_unlock(current); |
| |
| put_fs_struct(ofsp); |
| } |
| |
| /* |
| * At that point we are guaranteed to be the sole owner of |
| * current->fs. |
| */ |
| |
| current->personality = personality; |
| oep = current_thread_info()->exec_domain; |
| current_thread_info()->exec_domain = ep; |
| set_fs_altroot(); |
| |
| put_exec_domain(oep); |
| |
| printk(KERN_DEBUG "[%s:%d]: set personality to %lx\n", |
| current->comm, current->pid, personality); |
| return 0; |
| } |
| |
| int |
| get_exec_domain_list(char *page) |
| { |
| struct exec_domain *ep; |
| int len = 0; |
| |
| read_lock(&exec_domains_lock); |
| for (ep = exec_domains; ep && len < PAGE_SIZE - 80; ep = ep->next) |
| len += sprintf(page + len, "%d-%d\t%-16s\t[%s]\n", |
| ep->pers_low, ep->pers_high, ep->name, |
| ep->module ? ep->module->name : "kernel"); |
| read_unlock(&exec_domains_lock); |
| return (len); |
| } |
| |
| asmlinkage long |
| sys_personality(u_long personality) |
| { |
| u_long old = current->personality;; |
| |
| if (personality != 0xffffffff) { |
| set_personality(personality); |
| if (current->personality != personality) |
| return -EINVAL; |
| } |
| |
| return (long)old; |
| } |
| |
| |
| EXPORT_SYMBOL(register_exec_domain); |
| EXPORT_SYMBOL(unregister_exec_domain); |
| EXPORT_SYMBOL(__set_personality); |
| |
| /* |
| * We have to have all sysctl handling for the Linux-ABI |
| * in one place as the dynamic registration of sysctls is |
| * horribly crufty in Linux <= 2.4. |
| * |
| * I hope the new sysctl schemes discussed for future versions |
| * will obsolete this. |
| * |
| * --hch |
| */ |
| |
| u_long abi_defhandler_coff = PER_SCOSVR3; |
| u_long abi_defhandler_elf = PER_LINUX; |
| u_long abi_defhandler_lcall7 = PER_SVR4; |
| u_long abi_defhandler_libcso = PER_SVR4; |
| u_int abi_traceflg; |
| int abi_fake_utsname; |
| |
| static struct ctl_table abi_table[] = { |
| {ABI_DEFHANDLER_COFF, "defhandler_coff", &abi_defhandler_coff, |
| sizeof(int), 0644, NULL, &proc_doulongvec_minmax}, |
| {ABI_DEFHANDLER_ELF, "defhandler_elf", &abi_defhandler_elf, |
| sizeof(int), 0644, NULL, &proc_doulongvec_minmax}, |
| {ABI_DEFHANDLER_LCALL7, "defhandler_lcall7", &abi_defhandler_lcall7, |
| sizeof(int), 0644, NULL, &proc_doulongvec_minmax}, |
| {ABI_DEFHANDLER_LIBCSO, "defhandler_libcso", &abi_defhandler_libcso, |
| sizeof(int), 0644, NULL, &proc_doulongvec_minmax}, |
| {ABI_TRACE, "trace", &abi_traceflg, |
| sizeof(u_int), 0644, NULL, &proc_dointvec}, |
| {ABI_FAKE_UTSNAME, "fake_utsname", &abi_fake_utsname, |
| sizeof(int), 0644, NULL, &proc_dointvec}, |
| {0} |
| }; |
| |
| static struct ctl_table abi_root_table[] = { |
| {CTL_ABI, "abi", NULL, 0, 0555, abi_table}, |
| {0} |
| }; |
| |
| static int __init |
| abi_register_sysctl(void) |
| { |
| register_sysctl_table(abi_root_table, 1); |
| return 0; |
| } |
| |
| __initcall(abi_register_sysctl); |
| |
| |
| EXPORT_SYMBOL(abi_defhandler_coff); |
| EXPORT_SYMBOL(abi_defhandler_elf); |
| EXPORT_SYMBOL(abi_defhandler_lcall7); |
| EXPORT_SYMBOL(abi_defhandler_libcso); |
| EXPORT_SYMBOL(abi_traceflg); |
| EXPORT_SYMBOL(abi_fake_utsname); |