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 "stddebug.h"
  14 #include "debug.h"
  15
  16 #ifndef WINELIB
  17
  18 #ifdef linux
  19 #include <linux/unistd.h>
  20 #include <linux/head.h>
  21 #include <linux/ldt.h>
  22
  23 _syscall3(int, modify_ldt, int, func, void *, ptr, unsigned long, bytecount)
  24 #endif  /* linux */
  25 #if defined(__svr4__) || defined(_SCO_DS)
  26 #include <sys/sysi86.h>
  27 #include <sys/seg.h>
  28 #endif
  29
  30 #if defined(__NetBSD__) || defined(__FreeBSD__)
  31 #include <machine/segments.h>
  32
  33 extern int i386_get_ldt(int, union descriptor *, int);
  34 extern int i386_set_ldt(int, union descriptor *, int);
  35 #endif  /* __NetBSD__ || __FreeBSD__ */
  36
  37 #endif  /* ifndef WINELIB */
  38
  39
  40 ldt_copy_entry ldt_copy[LDT_SIZE] = { {0,0}, };
  41 unsigned char ldt_flags_copy[LDT_SIZE] = { 0, };
  42
  43
  44 /***********************************************************************
  45  *           LDT_BytesToEntry
  46  *
  47  * Convert the raw bytes of the descriptor to an ldt_entry structure.
  48  */
  49 void LDT_BytesToEntry( const unsigned long *buffer, ldt_entry *content )
  50 {
  51     content->base  = (*buffer >> 16) & 0x0000ffff;
  52     content->limit = *buffer & 0x0000ffff;
  53     buffer++;
  54     content->base  |= (*buffer & 0xff000000) | ((*buffer << 16) & 0x00ff0000);
  55     content->limit |= (*buffer & 0x000f0000);
  56     content->type           = (*buffer >> 10) & 3;
  57     content->seg_32bit      = (*buffer & 0x00400000) != 0;
  58     content->read_only      = (*buffer & 0x00000200) == 0;
  59     content->limit_in_pages = (*buffer & 0x00800000) != 0;
  60 }
  61
  62
  63 /***********************************************************************
  64  *           LDT_EntryToBytes
  65  *
  66  * Convert an ldt_entry structure to the raw bytes of the descriptor.
  67  */
  68 void LDT_EntryToBytes( unsigned long *buffer, const ldt_entry *content )
  69 {
  70     *buffer++ = ((content->base & 0x0000ffff) << 16) |
  71                  (content->limit & 0x0ffff);
  72     *buffer = (content->base & 0xff000000) |
  73               ((content->base & 0x00ff0000)>>16) |
  74               (content->limit & 0xf0000) |
  75               (content->type << 10) |
  76               ((content->read_only == 0) << 9) |
  77               ((content->seg_32bit != 0) << 22) |
  78               ((content->limit_in_pages != 0) << 23) |
  79               0xf000;
  80 }
  81
  82
  83 /***********************************************************************
  84  *           LDT_GetEntry
  85  *
  86  * Retrieve an LDT entry.
  87  */
  88 int LDT_GetEntry( int entry, ldt_entry *content )
  89 {
  90     int ret = 0;
  91
  92     content->base           = ldt_copy[entry].base;
  93     content->limit          = ldt_copy[entry].limit;
  94     content->type           = (ldt_flags_copy[entry] & LDT_FLAGS_TYPE);
  95     content->seg_32bit      = (ldt_flags_copy[entry] & LDT_FLAGS_32BIT) != 0;
  96     content->read_only      = (ldt_flags_copy[entry] & LDT_FLAGS_READONLY) !=0;
  97     content->limit_in_pages = (ldt_flags_copy[entry] & LDT_FLAGS_BIG) !=0;
  98     return ret;
  99 }
 100
 101
 102 /***********************************************************************
 103  *           LDT_SetEntry
 104  *
 105  * Set an LDT entry.
 106  */
 107 int LDT_SetEntry( int entry, const ldt_entry *content )
 108 {
 109     int ret = 0;
 110
 111     dprintf_ldt(stddeb,
 112           "LDT_SetEntry: entry=%04x base=%08lx limit=%05lx %s %d-bit flags=%c%c%c\n",
 113           entry, content->base, content->limit,
 114           content->limit_in_pages ? "pages" : "bytes",
 115           content->seg_32bit ? 32 : 16,
 116           content->read_only && (content->type & SEGMENT_CODE) ? '-' : 'r',
 117           content->read_only || (content->type & SEGMENT_CODE) ? '-' : 'w',
 118           (content->type & SEGMENT_CODE) ? 'x' : '-' );
 119
 120     /* Entry 0 must not be modified; its base and limit are always 0 */
 121     if (!entry) return 0;
 122
 123 #ifndef WINELIB
 124 #ifdef linux
 125     {
 126         struct modify_ldt_ldt_s ldt_info;
 127
 128         /* Clear all unused bits (like seg_not_present) */
 129         memset( &ldt_info, 0, sizeof(ldt_info) );
 130         ldt_info.entry_number   = entry;
 131         ldt_info.base_addr      = content->base;
 132         ldt_info.limit          = content->limit;
 133         ldt_info.seg_32bit      = content->seg_32bit != 0;
 134         ldt_info.contents       = content->type;
 135         ldt_info.read_exec_only = content->read_only != 0;
 136         ldt_info.limit_in_pages = content->limit_in_pages != 0;
 137         ret = modify_ldt(1, &ldt_info, sizeof(ldt_info));
 138     }
 139 #endif  /* linux */
 140
 141 #if defined(__NetBSD__) || defined(__FreeBSD__)
 142     {
 143         long d[2];
 144
 145         LDT_EntryToBytes( d, content );
 146         ret = i386_set_ldt(entry, (union descriptor *)d, 1);
 147         if (ret < 0)
 148         {
 149             perror("i386_set_ldt");
 150             fprintf(stderr,
 151                 "Did you reconfigure the kernel with \"options USER_LDT\"?\n");
 152             exit(1);
 153         }
 154     }
 155 #endif  /* __NetBSD__ || __FreeBSD__ */
 156 #if defined(__svr4__) || defined(_SCO_DS)
 157 {
 158     struct ssd ldt_mod;
 159     int i;
 160     ldt_mod.sel = ENTRY_TO_SELECTOR(entry) | 4;
 161     ldt_mod.bo = content->base;
 162     ldt_mod.ls = content->limit;
 163     i =   (content->limit & 0xf0000) |
 164         (content->type << 10) |
 165             (((content->read_only != 0) ^ 1) << 9) |
 166                 ((content->seg_32bit != 0) << 22) |
 167                     ((content->limit_in_pages != 0)<< 23) |
 168                         (1<<15) |
 169                             0x7000;
 170
 171     ldt_mod.acc1 = (i & 0xff00) >> 8;
 172     ldt_mod.acc2 = (i & 0xf00000) >> 20;
 173
 174
 175     if (content->base == 0)
 176     {
 177         ldt_mod.acc1 =  0;
 178         ldt_mod.acc2 = 0;
 179     }
 180     if ((i = sysi86(SI86DSCR, &ldt_mod)) == -1)
 181         perror("sysi86");
 182
 183 }
 184 #endif
 185 #endif  /* ifndef WINELIB */
 186
 187     if (ret < 0) return ret;
 188     ldt_copy[entry].base = content->base;
 189     if (!content->limit_in_pages) ldt_copy[entry].limit = content->limit;
 190     else ldt_copy[entry].limit = (content->limit << 12) | 0x0fff;
 191     ldt_flags_copy[entry] = (content->type & LDT_FLAGS_TYPE) |
 192                             (content->read_only ? LDT_FLAGS_READONLY : 0) |
 193                             (content->seg_32bit ? LDT_FLAGS_32BIT : 0) |
 194                             (content->limit_in_pages ? LDT_FLAGS_BIG : 0) |
 195                             (ldt_flags_copy[entry] & LDT_FLAGS_ALLOCATED);
 196     return ret;
 197 }
 198
 199
 200 /***********************************************************************
 201  *           LDT_Print
 202  *
 203  * Print the content of the LDT on stdout.
 204  */
 205 #ifndef WINELIB
 206 void LDT_Print( int start, int length )
 207 {
 208     int i;
 209     char flags[3];
 210
 211     if (length == -1) length = LDT_SIZE - start;
 212     for (i = start; i < start + length; i++)
 213     {
 214         if (!ldt_copy[i].base && !ldt_copy[i].limit) continue; /* Free entry */
 215         if ((ldt_flags_copy[i] & LDT_FLAGS_TYPE) == SEGMENT_CODE)
 216         {
 217             flags[0] = (ldt_flags_copy[i] & LDT_FLAGS_EXECONLY) ? '-' : 'r';
 218             flags[1] = '-';
 219             flags[2] = 'x';
 220         }
 221         else
 222         {
 223             flags[0] = 'r';
 224             flags[1] = (ldt_flags_copy[i] & LDT_FLAGS_READONLY) ? '-' : 'w';
 225             flags[2] = '-';
 226         }
 227         printf("%04x: sel=%04x base=%08lx limit=%05lx %s %d-bit %c%c%c\n",
 228                 i, ENTRY_TO_SELECTOR(i),
 229                 ldt_copy[i].base, ldt_copy[i].limit,
 230                 ldt_flags_copy[i] & LDT_FLAGS_BIG ? "(pages)" : "(bytes)",
 231                 ldt_flags_copy[i] & LDT_FLAGS_32BIT ? 32 : 16,
 232                 flags[0], flags[1], flags[2] );
 233     }
 234 }
 235 #endif  /* WINELIB */