memory/ldt.c

   1 /*
   2  * LDT manipulation functions
   3  *
   4  * Copyright 1993 Robert J. Amstadt
   5  * Copyright 1995 Alexandre Julliard
   6  */
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <errno.h>
  12 #include "ldt.h"
  13 #include "debug.h"
  14
  15 #ifdef __i386__
  16
  17 #ifdef linux
  18 #include <sys/syscall.h>
  19
  20 struct modify_ldt_s
  21 {
  22     unsigned int  entry_number;
  23     unsigned long base_addr;
  24     unsigned int  limit;
  25     unsigned int  seg_32bit : 1;
  26     unsigned int  contents : 2;
  27     unsigned int  read_exec_only : 1;
  28     unsigned int  limit_in_pages : 1;
  29     unsigned int  seg_not_present : 1;
  30 };
  31
  32 static __inline__ int modify_ldt( int func, struct modify_ldt_s *ptr,
  33                                   unsigned long count )
  34 {
  35     int res;
  36 #ifdef __PIC__
  37     __asm__ __volatile__( "pushl %%ebx\n\t"
  38                           "movl %2,%%ebx\n\t"
  39                           "int $0x80\n\t"
  40                           "popl %%ebx"
  41                           : "=a" (res)
  42                           : "0" (SYS_modify_ldt),
  43                             "g" (func),
  44                             "c" (ptr),
  45                             "d" (count) );
  46 #else
  47     __asm__ __volatile__("int $0x80"
  48                          : "=a" (res)
  49                          : "0" (SYS_modify_ldt),
  50                            "b" (func),
  51                            "c" (ptr),
  52                            "d" (count) );
  53 #endif  /* __PIC__ */
  54     if (res >= 0) return res;
  55     errno = -res;
  56     return -1;
  57 }
  58
  59 #endif  /* linux */
  60
  61 #if defined(__svr4__) || defined(_SCO_DS)
  62 #include <sys/sysi86.h>
  63 #ifndef __sun__
  64 #include <sys/seg.h>
  65 #endif
  66 #endif
  67
  68 #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
  69 #include <machine/segments.h>
  70
  71 extern int i386_get_ldt(int, union descriptor *, int);
  72 extern int i386_set_ldt(int, union descriptor *, int);
  73 #endif  /* __NetBSD__ || __FreeBSD__ || __OpenBSD__ */
  74
  75 #endif  /* __i386__ */
  76
  77
  78 ldt_copy_entry ldt_copy[LDT_SIZE];
  79 unsigned char ldt_flags_copy[LDT_SIZE];
  80
  81
  82 /***********************************************************************
  83  *           LDT_BytesToEntry
  84  *
  85  * Convert the raw bytes of the descriptor to an ldt_entry structure.
  86  */
  87 void LDT_BytesToEntry( const unsigned long *buffer, ldt_entry *content )
  88 {
  89     content->base  = (*buffer >> 16) & 0x0000ffff;
  90     content->limit = *buffer & 0x0000ffff;
  91     buffer++;
  92     content->base  |= (*buffer & 0xff000000) | ((*buffer << 16) & 0x00ff0000);
  93     content->limit |= (*buffer & 0x000f0000);
  94     content->type           = (*buffer >> 10) & 3;
  95     content->seg_32bit      = (*buffer & 0x00400000) != 0;
  96     content->read_only      = (*buffer & 0x00000200) == 0;
  97     content->limit_in_pages = (*buffer & 0x00800000) != 0;
  98 }
  99
 100
 101 /***********************************************************************
 102  *           LDT_EntryToBytes
 103  *
 104  * Convert an ldt_entry structure to the raw bytes of the descriptor.
 105  */
 106 void LDT_EntryToBytes( unsigned long *buffer, const ldt_entry *content )
 107 {
 108     *buffer++ = ((content->base & 0x0000ffff) << 16) |
 109                  (content->limit & 0x0ffff);
 110     *buffer = (content->base & 0xff000000) |
 111               ((content->base & 0x00ff0000)>>16) |
 112               (content->limit & 0xf0000) |
 113               (content->type << 10) |
 114               ((content->read_only == 0) << 9) |
 115               ((content->seg_32bit != 0) << 22) |
 116               ((content->limit_in_pages != 0) << 23) |
 117               0xf000;
 118 }
 119
 120
 121 /***********************************************************************
 122  *           LDT_GetEntry
 123  *
 124  * Retrieve an LDT entry.
 125  */
 126 int LDT_GetEntry( int entry, ldt_entry *content )
 127 {
 128     int ret = 0;
 129
 130     content->base           = ldt_copy[entry].base;
 131     content->limit          = ldt_copy[entry].limit;
 132     content->type           = (ldt_flags_copy[entry] & LDT_FLAGS_TYPE);
 133     content->seg_32bit      = (ldt_flags_copy[entry] & LDT_FLAGS_32BIT) != 0;
 134     content->read_only      = (ldt_flags_copy[entry] & LDT_FLAGS_READONLY) !=0;
 135     content->limit_in_pages = (ldt_flags_copy[entry] & LDT_FLAGS_BIG) !=0;
 136     if (content->limit_in_pages) content->limit >>= 12;
 137     return ret;
 138 }
 139
 140
 141 /***********************************************************************
 142  *           LDT_SetEntry
 143  *
 144  * Set an LDT entry.
 145  */
 146 int LDT_SetEntry( int entry, const ldt_entry *content )
 147 {
 148     int ret = 0;
 149
 150     dprintf_info(ldt,
 151           "LDT_SetEntry: entry=%04x base=%08lx limit=%05lx %s %d-bit flags=%c%c%c\n",
 152           entry, content->base, content->limit,
 153           content->limit_in_pages ? "pages" : "bytes",
 154           content->seg_32bit ? 32 : 16,
 155           content->read_only && (content->type & SEGMENT_CODE) ? '-' : 'r',
 156           content->read_only || (content->type & SEGMENT_CODE) ? '-' : 'w',
 157           (content->type & SEGMENT_CODE) ? 'x' : '-' );
 158
 159     /* Entry 0 must not be modified; its base and limit are always 0 */
 160     if (!entry) return 0;
 161
 162 #ifdef __i386__
 163
 164 #ifdef linux
 165     {
 166         struct modify_ldt_s ldt_info;
 167
 168         ldt_info.entry_number    = entry;
 169         ldt_info.base_addr       = content->base;
 170         ldt_info.limit           = content->limit;
 171         ldt_info.seg_32bit       = content->seg_32bit != 0;
 172         ldt_info.contents        = content->type;
 173         ldt_info.read_exec_only  = content->read_only != 0;
 174         ldt_info.limit_in_pages  = content->limit_in_pages != 0;
 175         ldt_info.seg_not_present = 0;
 176         /* Make sure the info will be accepted by the kernel */
 177         /* This is ugly, but what can I do? */
 178         if (content->type == SEGMENT_STACK)
 179         {
 180             /* FIXME */
 181         }
 182         else
 183         {
 184             if (ldt_info.base_addr >= 0xc0000000)
 185             {
 186                 fprintf( stderr, "LDT_SetEntry: invalid base addr %08lx\n",
 187                          ldt_info.base_addr );
 188                 return -1;
 189             }
 190             if (content->limit_in_pages)
 191             {
 192                 if ((ldt_info.limit << 12) + 0xfff >
 193                                                0xc0000000 - ldt_info.base_addr)
 194                     ldt_info.limit = (0xc0000000 - 0xfff - ldt_info.base_addr) >> 12;
 195             }
 196             else
 197             {
 198                 if (ldt_info.limit > 0xc0000000 - ldt_info.base_addr)
 199                     ldt_info.limit = 0xc0000000 - ldt_info.base_addr;
 200             }
 201         }
 202         if ((ret = modify_ldt(1, &ldt_info, sizeof(ldt_info))) < 0)
 203             perror( "modify_ldt" );
 204     }
 205 #endif  /* linux */
 206
 207 #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
 208     {
 209         long d[2];
 210
 211         LDT_EntryToBytes( d, content );
 212         ret = i386_set_ldt(entry, (union descriptor *)d, 1);
 213         if (ret < 0)
 214         {
 215             perror("i386_set_ldt");
 216             fprintf(stderr,
 217                 "Did you reconfigure the kernel with \"options USER_LDT\"?\n");
 218             exit(1);
 219         }
 220     }
 221 #endif  /* __NetBSD__ || __FreeBSD__ || __OpenBSD__ */
 222
 223 #if defined(__svr4__) || defined(_SCO_DS)
 224     {
 225         struct ssd ldt_mod;
 226         int i;
 227         ldt_mod.sel = ENTRY_TO_SELECTOR(entry) | 4;
 228         ldt_mod.bo = content->base;
 229         ldt_mod.ls = content->limit;
 230         i = ((content->limit & 0xf0000) |
 231              (content->type << 10) |
 232              (((content->read_only != 0) ^ 1) << 9) |
 233              ((content->seg_32bit != 0) << 22) |
 234              ((content->limit_in_pages != 0)<< 23) |
 235              (1<<15) |
 236              0x7000);
 237
 238         ldt_mod.acc1 = (i & 0xff00) >> 8;
 239         ldt_mod.acc2 = (i & 0xf00000) >> 20;
 240
 241         if (content->base == 0)
 242         {
 243             ldt_mod.acc1 =  0;
 244             ldt_mod.acc2 = 0;
 245         }
 246         if ((ret = sysi86(SI86DSCR, &ldt_mod)) == -1) perror("sysi86");
 247     }
 248 #endif
 249
 250 #endif  /* __i386__ */
 251
 252     if (ret < 0) return ret;
 253     ldt_copy[entry].base = content->base;
 254     if (!content->limit_in_pages) ldt_copy[entry].limit = content->limit;
 255     else ldt_copy[entry].limit = (content->limit << 12) | 0x0fff;
 256     ldt_flags_copy[entry] = (content->type & LDT_FLAGS_TYPE) |
 257                             (content->read_only ? LDT_FLAGS_READONLY : 0) |
 258                             (content->seg_32bit ? LDT_FLAGS_32BIT : 0) |
 259                             (content->limit_in_pages ? LDT_FLAGS_BIG : 0) |
 260                             (ldt_flags_copy[entry] & LDT_FLAGS_ALLOCATED);
 261     return ret;
 262 }
 263
 264
 265 /***********************************************************************
 266  *           LDT_Print
 267  *
 268  * Print the content of the LDT on stdout.
 269  */
 270 void LDT_Print( int start, int length )
 271 {
 272     int i;
 273     char flags[3];
 274
 275     if (length == -1) length = LDT_SIZE - start;
 276     for (i = start; i < start + length; i++)
 277     {
 278         if (!ldt_copy[i].base && !ldt_copy[i].limit) continue; /* Free entry */
 279         if ((ldt_flags_copy[i] & LDT_FLAGS_TYPE) == SEGMENT_CODE)
 280         {
 281             flags[0] = (ldt_flags_copy[i] & LDT_FLAGS_EXECONLY) ? '-' : 'r';
 282             flags[1] = '-';
 283             flags[2] = 'x';
 284         }
 285         else
 286         {
 287             flags[0] = 'r';
 288             flags[1] = (ldt_flags_copy[i] & LDT_FLAGS_READONLY) ? '-' : 'w';
 289             flags[2] = '-';
 290         }
 291         fprintf(stderr,"%04x: sel=%04x base=%08lx limit=%08lx %d-bit %c%c%c\n",
 292                 i, ENTRY_TO_SELECTOR(i),
 293                 ldt_copy[i].base, ldt_copy[i].limit,
 294                 ldt_flags_copy[i] & LDT_FLAGS_32BIT ? 32 : 16,
 295                 flags[0], flags[1], flags[2] );
 296     }
 297 }