SAFE public projects git trees. - safe/jmp/linux-2.6/blob - kernel/exec_domain.c

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