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/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_MODULES
  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
 172         module_put(oep->module);
 173         return 0;
 174 }
 175
 176 int
 177 get_exec_domain_list(char *page)
 178 {
 179         struct exec_domain      *ep;
 180         int                     len = 0;
 181
 182         read_lock(&exec_domains_lock);
 183         for (ep = exec_domains; ep && len < PAGE_SIZE - 80; ep = ep->next)
 184                 len += sprintf(page + len, "%d-%d\t%-16s\t[%s]\n",
 185                                ep->pers_low, ep->pers_high, ep->name,
 186                                module_name(ep->module));
 187         read_unlock(&exec_domains_lock);
 188         return (len);
 189 }
 190
 191 SYSCALL_DEFINE1(personality, u_long, personality)
 192 {
 193         u_long old = current->personality;
 194
 195         if (personality != 0xffffffff) {
 196                 set_personality(personality);
 197                 if (current->personality != personality)
 198                         return -EINVAL;
 199         }
 200
 201         return (long)old;
 202 }
 203
 204
 205 EXPORT_SYMBOL(register_exec_domain);
 206 EXPORT_SYMBOL(unregister_exec_domain);
 207 EXPORT_SYMBOL(__set_personality);