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 module_put(ep->module); 144 return 0; 145 } 146 147 if (atomic_read(¤t->fs->count) != 1) { 148 struct fs_struct *fsp, *ofsp; 149 150 fsp = copy_fs_struct(current->fs); 151 if (fsp == NULL) { 152 module_put(ep->module); 153 return -ENOMEM; 154 } 155 156 task_lock(current); 157 ofsp = current->fs; 158 current->fs = fsp; 159 task_unlock(current); 160 161 put_fs_struct(ofsp); 162 } 163 164 /* 165 * At that point we are guaranteed to be the sole owner of 166 * current->fs. 167 */ 168 169 current->personality = personality; 170 oep = current_thread_info()->exec_domain; 171 current_thread_info()->exec_domain = ep; 172 set_fs_altroot(); 173 174 module_put(oep->module); 175 return 0; 176 } 177 178 int 179 get_exec_domain_list(char *page) 180 { 181 struct exec_domain *ep; 182 int len = 0; 183 184 read_lock(&exec_domains_lock); 185 for (ep = exec_domains; ep && len < PAGE_SIZE - 80; ep = ep->next) 186 len += sprintf(page + len, "%d-%d\t%-16s\t[%s]\n", 187 ep->pers_low, ep->pers_high, ep->name, 188 module_name(ep->module)); 189 read_unlock(&exec_domains_lock); 190 return (len); 191 } 192 193 asmlinkage long 194 sys_personality(u_long personality) 195 { 196 u_long old = current->personality; 197 198 if (personality != 0xffffffff) { 199 set_personality(personality); 200 if (current->personality != personality) 201 return -EINVAL; 202 } 203 204 return (long)old; 205 } 206 207 208 EXPORT_SYMBOL(register_exec_domain); 209 EXPORT_SYMBOL(unregister_exec_domain); 210 EXPORT_SYMBOL(__set_personality); 211