mirror of
git://source.winehq.org/git/wine.git
synced 2024-11-05 18:01:34 +00:00
ce13153821
Added support for correct locking of all LDT operations. Added separate functions to manipulate the %fs selector, which allows using a global GDT selector on recent Linux kernels.
849 lines
25 KiB
C
849 lines
25 KiB
C
/*
|
|
* Selector manipulation functions
|
|
*
|
|
* Copyright 1995 Alexandre Julliard
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include "wine/port.h"
|
|
|
|
#include <string.h>
|
|
|
|
#include "winerror.h"
|
|
#include "wine/winbase16.h"
|
|
#include "miscemu.h"
|
|
#include "selectors.h"
|
|
#include "stackframe.h"
|
|
#include "wine/server.h"
|
|
#include "wine/debug.h"
|
|
#include "toolhelp.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(selector);
|
|
|
|
#define LDT_SIZE 8192
|
|
|
|
/* get the number of selectors needed to cover up to the selector limit */
|
|
inline static WORD get_sel_count( WORD sel )
|
|
{
|
|
return (wine_ldt_copy.limit[sel >> __AHSHIFT] >> 16) + 1;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* AllocSelectorArray (KERNEL.206)
|
|
*/
|
|
WORD WINAPI AllocSelectorArray16( WORD count )
|
|
{
|
|
WORD i, sel = wine_ldt_alloc_entries( count );
|
|
|
|
if (sel)
|
|
{
|
|
LDT_ENTRY entry;
|
|
wine_ldt_set_base( &entry, 0 );
|
|
wine_ldt_set_limit( &entry, 1 ); /* avoid 0 base and limit */
|
|
wine_ldt_set_flags( &entry, WINE_LDT_FLAGS_DATA );
|
|
for (i = 0; i < count; i++) wine_ldt_set_entry( sel + (i << __AHSHIFT), &entry );
|
|
}
|
|
return sel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* AllocSelector (KERNEL.175)
|
|
*/
|
|
WORD WINAPI AllocSelector16( WORD sel )
|
|
{
|
|
WORD newsel, count, i;
|
|
|
|
count = sel ? get_sel_count(sel) : 1;
|
|
newsel = wine_ldt_alloc_entries( count );
|
|
TRACE("(%04x): returning %04x\n", sel, newsel );
|
|
if (!newsel) return 0;
|
|
if (!sel) return newsel; /* nothing to copy */
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
LDT_ENTRY entry;
|
|
wine_ldt_get_entry( sel + (i << __AHSHIFT), &entry );
|
|
wine_ldt_set_entry( newsel + (i << __AHSHIFT), &entry );
|
|
}
|
|
return newsel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* FreeSelector (KERNEL.176)
|
|
*/
|
|
WORD WINAPI FreeSelector16( WORD sel )
|
|
{
|
|
LDT_ENTRY entry;
|
|
|
|
wine_ldt_get_entry( sel, &entry );
|
|
if (wine_ldt_is_empty( &entry )) return sel; /* error */
|
|
#ifdef __i386__
|
|
/* Check if we are freeing current %fs selector */
|
|
if (!((wine_get_fs() ^ sel) & ~3))
|
|
WARN("Freeing %%fs selector (%04x), not good.\n", wine_get_fs() );
|
|
#endif /* __i386__ */
|
|
wine_ldt_free_entries( sel, 1 );
|
|
return 0;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SELECTOR_SetEntries
|
|
*
|
|
* Set the LDT entries for an array of selectors.
|
|
*/
|
|
static void SELECTOR_SetEntries( WORD sel, const void *base, DWORD size, unsigned char flags )
|
|
{
|
|
LDT_ENTRY entry;
|
|
WORD i, count;
|
|
|
|
wine_ldt_set_base( &entry, base );
|
|
wine_ldt_set_limit( &entry, size - 1 );
|
|
wine_ldt_set_flags( &entry, flags );
|
|
count = (size + 0xffff) / 0x10000;
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
wine_ldt_set_entry( sel + (i << __AHSHIFT), &entry );
|
|
wine_ldt_set_base( &entry, (char*)wine_ldt_get_base(&entry) + 0x10000);
|
|
/* yep, Windows sets limit like that, not 64K sel units */
|
|
wine_ldt_set_limit( &entry, wine_ldt_get_limit(&entry) - 0x10000 );
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SELECTOR_AllocBlock
|
|
*
|
|
* Allocate selectors for a block of linear memory.
|
|
*/
|
|
WORD SELECTOR_AllocBlock( const void *base, DWORD size, unsigned char flags )
|
|
{
|
|
WORD sel, count;
|
|
|
|
if (!size) return 0;
|
|
count = (size + 0xffff) / 0x10000;
|
|
sel = wine_ldt_alloc_entries( count );
|
|
if (sel) SELECTOR_SetEntries( sel, base, size, flags );
|
|
return sel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SELECTOR_FreeBlock
|
|
*
|
|
* Free a block of selectors.
|
|
*/
|
|
void SELECTOR_FreeBlock( WORD sel )
|
|
{
|
|
WORD i, count = get_sel_count( sel );
|
|
|
|
TRACE("(%04x,%d)\n", sel, count );
|
|
for (i = 0; i < count; i++) FreeSelector16( sel + (i << __AHSHIFT) );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SELECTOR_ReallocBlock
|
|
*
|
|
* Change the size of a block of selectors.
|
|
*/
|
|
WORD SELECTOR_ReallocBlock( WORD sel, const void *base, DWORD size )
|
|
{
|
|
LDT_ENTRY entry;
|
|
int oldcount, newcount;
|
|
|
|
if (!size) size = 1;
|
|
wine_ldt_get_entry( sel, &entry );
|
|
oldcount = (wine_ldt_get_limit(&entry) >> 16) + 1;
|
|
newcount = (size + 0xffff) >> 16;
|
|
|
|
sel = wine_ldt_realloc_entries( sel, oldcount, newcount );
|
|
if (sel) SELECTOR_SetEntries( sel, base, size, wine_ldt_get_flags(&entry) );
|
|
return sel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* PrestoChangoSelector (KERNEL.177)
|
|
*/
|
|
WORD WINAPI PrestoChangoSelector16( WORD selSrc, WORD selDst )
|
|
{
|
|
LDT_ENTRY entry;
|
|
wine_ldt_get_entry( selSrc, &entry );
|
|
/* toggle the executable bit */
|
|
entry.HighWord.Bits.Type ^= (WINE_LDT_FLAGS_CODE ^ WINE_LDT_FLAGS_DATA);
|
|
wine_ldt_set_entry( selDst, &entry );
|
|
return selDst;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* AllocCStoDSAlias (KERNEL.170)
|
|
* AllocAlias (KERNEL.172)
|
|
*/
|
|
WORD WINAPI AllocCStoDSAlias16( WORD sel )
|
|
{
|
|
WORD newsel;
|
|
LDT_ENTRY entry;
|
|
|
|
newsel = wine_ldt_alloc_entries( 1 );
|
|
TRACE("(%04x): returning %04x\n",
|
|
sel, newsel );
|
|
if (!newsel) return 0;
|
|
wine_ldt_get_entry( sel, &entry );
|
|
entry.HighWord.Bits.Type = WINE_LDT_FLAGS_DATA;
|
|
wine_ldt_set_entry( newsel, &entry );
|
|
return newsel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* AllocDStoCSAlias (KERNEL.171)
|
|
*/
|
|
WORD WINAPI AllocDStoCSAlias16( WORD sel )
|
|
{
|
|
WORD newsel;
|
|
LDT_ENTRY entry;
|
|
|
|
newsel = wine_ldt_alloc_entries( 1 );
|
|
TRACE("(%04x): returning %04x\n",
|
|
sel, newsel );
|
|
if (!newsel) return 0;
|
|
wine_ldt_get_entry( sel, &entry );
|
|
entry.HighWord.Bits.Type = WINE_LDT_FLAGS_CODE;
|
|
wine_ldt_set_entry( newsel, &entry );
|
|
return newsel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* LongPtrAdd (KERNEL.180)
|
|
*/
|
|
void WINAPI LongPtrAdd16( DWORD ptr, DWORD add )
|
|
{
|
|
LDT_ENTRY entry;
|
|
wine_ldt_get_entry( SELECTOROF(ptr), &entry );
|
|
wine_ldt_set_base( &entry, (char *)wine_ldt_get_base(&entry) + add );
|
|
wine_ldt_set_entry( SELECTOROF(ptr), &entry );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* GetSelectorBase (KERNEL.186)
|
|
*/
|
|
DWORD WINAPI GetSelectorBase( WORD sel )
|
|
{
|
|
void *base = wine_ldt_copy.base[sel >> __AHSHIFT];
|
|
|
|
/* if base points into DOSMEM, assume we have to
|
|
* return pointer into physical lower 1MB */
|
|
|
|
return DOSMEM_MapLinearToDos( base );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SetSelectorBase (KERNEL.187)
|
|
*/
|
|
WORD WINAPI SetSelectorBase( WORD sel, DWORD base )
|
|
{
|
|
LDT_ENTRY entry;
|
|
wine_ldt_get_entry( sel, &entry );
|
|
wine_ldt_set_base( &entry, DOSMEM_MapDosToLinear(base) );
|
|
wine_ldt_set_entry( sel, &entry );
|
|
return sel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* GetSelectorLimit (KERNEL.188)
|
|
*/
|
|
DWORD WINAPI GetSelectorLimit16( WORD sel )
|
|
{
|
|
return wine_ldt_copy.limit[sel >> __AHSHIFT];
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SetSelectorLimit (KERNEL.189)
|
|
*/
|
|
WORD WINAPI SetSelectorLimit16( WORD sel, DWORD limit )
|
|
{
|
|
LDT_ENTRY entry;
|
|
wine_ldt_get_entry( sel, &entry );
|
|
wine_ldt_set_limit( &entry, limit );
|
|
wine_ldt_set_entry( sel, &entry );
|
|
return sel;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SelectorAccessRights (KERNEL.196)
|
|
*/
|
|
WORD WINAPI SelectorAccessRights16( WORD sel, WORD op, WORD val )
|
|
{
|
|
LDT_ENTRY entry;
|
|
wine_ldt_get_entry( sel, &entry );
|
|
|
|
if (op == 0) /* get */
|
|
{
|
|
return entry.HighWord.Bytes.Flags1 | ((entry.HighWord.Bytes.Flags2 << 8) & 0xf0);
|
|
}
|
|
else /* set */
|
|
{
|
|
entry.HighWord.Bytes.Flags1 = LOBYTE(val) | 0xf0;
|
|
entry.HighWord.Bytes.Flags2 = (entry.HighWord.Bytes.Flags2 & 0x0f) | (HIBYTE(val) & 0xf0);
|
|
wine_ldt_set_entry( sel, &entry );
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* IsBadCodePtr (KERNEL.336)
|
|
*/
|
|
BOOL16 WINAPI IsBadCodePtr16( SEGPTR lpfn )
|
|
{
|
|
WORD sel;
|
|
LDT_ENTRY entry;
|
|
|
|
sel = SELECTOROF(lpfn);
|
|
if (!sel) return TRUE;
|
|
wine_ldt_get_entry( sel, &entry );
|
|
if (wine_ldt_is_empty( &entry )) return TRUE;
|
|
/* check for code segment, ignoring conforming, read-only and accessed bits */
|
|
if ((entry.HighWord.Bits.Type ^ WINE_LDT_FLAGS_CODE) & 0x18) return TRUE;
|
|
if (OFFSETOF(lpfn) > wine_ldt_get_limit(&entry)) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* IsBadStringPtr (KERNEL.337)
|
|
*/
|
|
BOOL16 WINAPI IsBadStringPtr16( SEGPTR ptr, UINT16 size )
|
|
{
|
|
WORD sel;
|
|
LDT_ENTRY entry;
|
|
|
|
sel = SELECTOROF(ptr);
|
|
if (!sel) return TRUE;
|
|
wine_ldt_get_entry( sel, &entry );
|
|
if (wine_ldt_is_empty( &entry )) return TRUE;
|
|
/* check for data or readable code segment */
|
|
if (!(entry.HighWord.Bits.Type & 0x10)) return TRUE; /* system descriptor */
|
|
if ((entry.HighWord.Bits.Type & 0x0a) == 0x08) return TRUE; /* non-readable code segment */
|
|
if (strlen(MapSL(ptr)) < size) size = strlen(MapSL(ptr)) + 1;
|
|
if (size && (OFFSETOF(ptr) + size - 1 > wine_ldt_get_limit(&entry))) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* IsBadHugeReadPtr (KERNEL.346)
|
|
*/
|
|
BOOL16 WINAPI IsBadHugeReadPtr16( SEGPTR ptr, DWORD size )
|
|
{
|
|
WORD sel;
|
|
LDT_ENTRY entry;
|
|
|
|
sel = SELECTOROF(ptr);
|
|
if (!sel) return TRUE;
|
|
wine_ldt_get_entry( sel, &entry );
|
|
if (wine_ldt_is_empty( &entry )) return TRUE;
|
|
/* check for data or readable code segment */
|
|
if (!(entry.HighWord.Bits.Type & 0x10)) return TRUE; /* system descriptor */
|
|
if ((entry.HighWord.Bits.Type & 0x0a) == 0x08) return TRUE; /* non-readable code segment */
|
|
if (size && (OFFSETOF(ptr) + size - 1 > wine_ldt_get_limit( &entry ))) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* IsBadHugeWritePtr (KERNEL.347)
|
|
*/
|
|
BOOL16 WINAPI IsBadHugeWritePtr16( SEGPTR ptr, DWORD size )
|
|
{
|
|
WORD sel;
|
|
LDT_ENTRY entry;
|
|
|
|
sel = SELECTOROF(ptr);
|
|
if (!sel) return TRUE;
|
|
wine_ldt_get_entry( sel, &entry );
|
|
if (wine_ldt_is_empty( &entry )) return TRUE;
|
|
/* check for writeable data segment, ignoring expand-down and accessed flags */
|
|
if ((entry.HighWord.Bits.Type ^ WINE_LDT_FLAGS_DATA) & ~5) return TRUE;
|
|
if (size && (OFFSETOF(ptr) + size - 1 > wine_ldt_get_limit( &entry ))) return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* IsBadReadPtr (KERNEL.334)
|
|
*/
|
|
BOOL16 WINAPI IsBadReadPtr16( SEGPTR ptr, UINT16 size )
|
|
{
|
|
return IsBadHugeReadPtr16( ptr, size );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* IsBadWritePtr (KERNEL.335)
|
|
*/
|
|
BOOL16 WINAPI IsBadWritePtr16( SEGPTR ptr, UINT16 size )
|
|
{
|
|
return IsBadHugeWritePtr16( ptr, size );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* IsBadFlatReadWritePtr (KERNEL.627)
|
|
*/
|
|
BOOL16 WINAPI IsBadFlatReadWritePtr16( SEGPTR ptr, DWORD size, BOOL16 bWrite )
|
|
{
|
|
return bWrite? IsBadHugeWritePtr16( ptr, size )
|
|
: IsBadHugeReadPtr16( ptr, size );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* MemoryRead (TOOLHELP.78)
|
|
*/
|
|
DWORD WINAPI MemoryRead16( WORD sel, DWORD offset, void *buffer, DWORD count )
|
|
{
|
|
LDT_ENTRY entry;
|
|
DWORD limit;
|
|
|
|
wine_ldt_get_entry( sel, &entry );
|
|
if (wine_ldt_is_empty( &entry )) return 0;
|
|
limit = wine_ldt_get_limit( &entry );
|
|
if (offset > limit) return 0;
|
|
if (offset + count > limit + 1) count = limit + 1 - offset;
|
|
memcpy( buffer, (char *)wine_ldt_get_base(&entry) + offset, count );
|
|
return count;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* MemoryWrite (TOOLHELP.79)
|
|
*/
|
|
DWORD WINAPI MemoryWrite16( WORD sel, DWORD offset, void *buffer, DWORD count )
|
|
{
|
|
LDT_ENTRY entry;
|
|
DWORD limit;
|
|
|
|
wine_ldt_get_entry( sel, &entry );
|
|
if (wine_ldt_is_empty( &entry )) return 0;
|
|
limit = wine_ldt_get_limit( &entry );
|
|
if (offset > limit) return 0;
|
|
if (offset + count > limit) count = limit + 1 - offset;
|
|
memcpy( (char *)wine_ldt_get_base(&entry) + offset, buffer, count );
|
|
return count;
|
|
}
|
|
|
|
/************************************* Win95 pointer mapping functions *
|
|
*
|
|
*/
|
|
|
|
struct mapls_entry
|
|
{
|
|
struct mapls_entry *next;
|
|
void *addr; /* linear address */
|
|
int count; /* ref count */
|
|
WORD sel; /* selector */
|
|
};
|
|
|
|
static struct mapls_entry *first_entry;
|
|
|
|
|
|
/***********************************************************************
|
|
* MapLS (KERNEL32.@)
|
|
* MapLS (KERNEL.358)
|
|
*
|
|
* Maps linear pointer to segmented.
|
|
*/
|
|
SEGPTR WINAPI MapLS( LPCVOID ptr )
|
|
{
|
|
struct mapls_entry *entry, *free = NULL;
|
|
void *base;
|
|
SEGPTR ret = 0;
|
|
|
|
if (!HIWORD(ptr)) return (SEGPTR)ptr;
|
|
|
|
base = (char *)ptr - ((unsigned int)ptr & 0x7fff);
|
|
HeapLock( GetProcessHeap() );
|
|
for (entry = first_entry; entry; entry = entry->next)
|
|
{
|
|
if (entry->addr == base) break;
|
|
if (!entry->count) free = entry;
|
|
}
|
|
|
|
if (!entry)
|
|
{
|
|
if (!free) /* no free entry found, create a new one */
|
|
{
|
|
if (!(free = HeapAlloc( GetProcessHeap(), 0, sizeof(*free) ))) goto done;
|
|
if (!(free->sel = SELECTOR_AllocBlock( base, 0x10000, WINE_LDT_FLAGS_DATA )))
|
|
{
|
|
HeapFree( GetProcessHeap(), 0, free );
|
|
goto done;
|
|
}
|
|
free->count = 0;
|
|
free->next = first_entry;
|
|
first_entry = free;
|
|
}
|
|
SetSelectorBase( free->sel, (DWORD)base );
|
|
free->addr = base;
|
|
entry = free;
|
|
}
|
|
entry->count++;
|
|
ret = MAKESEGPTR( entry->sel, (char *)ptr - (char *)entry->addr );
|
|
done:
|
|
HeapUnlock( GetProcessHeap() );
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* UnMapLS (KERNEL32.@)
|
|
* UnMapLS (KERNEL.359)
|
|
*
|
|
* Free mapped selector.
|
|
*/
|
|
void WINAPI UnMapLS( SEGPTR sptr )
|
|
{
|
|
struct mapls_entry *entry;
|
|
WORD sel = SELECTOROF(sptr);
|
|
|
|
if (sel)
|
|
{
|
|
HeapLock( GetProcessHeap() );
|
|
for (entry = first_entry; entry; entry = entry->next) if (entry->sel == sel) break;
|
|
if (entry && entry->count > 0) entry->count--;
|
|
HeapUnlock( GetProcessHeap() );
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MapSL (KERNEL32.@)
|
|
* MapSL (KERNEL.357)
|
|
*
|
|
* Maps fixed segmented pointer to linear.
|
|
*/
|
|
LPVOID WINAPI MapSL( SEGPTR sptr )
|
|
{
|
|
return (char *)wine_ldt_copy.base[SELECTOROF(sptr) >> __AHSHIFT] + OFFSETOF(sptr);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* MapSLFix (KERNEL32.@)
|
|
*
|
|
* FIXME: MapSLFix and UnMapSLFixArray should probably prevent
|
|
* unexpected linear address change when GlobalCompact() shuffles
|
|
* moveable blocks.
|
|
*/
|
|
|
|
LPVOID WINAPI MapSLFix( SEGPTR sptr )
|
|
{
|
|
return MapSL(sptr);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* UnMapSLFixArray (KERNEL32.@)
|
|
*/
|
|
|
|
void WINAPI UnMapSLFixArray( SEGPTR sptr[], INT length, CONTEXT86 *context )
|
|
{
|
|
/* Must not change EAX, hence defined as 'register' function */
|
|
}
|
|
|
|
/***********************************************************************
|
|
* GetThreadSelectorEntry (KERNEL32.@)
|
|
*/
|
|
BOOL WINAPI GetThreadSelectorEntry( HANDLE hthread, DWORD sel, LPLDT_ENTRY ldtent)
|
|
{
|
|
#ifdef __i386__
|
|
BOOL ret;
|
|
|
|
if (!(sel & 4)) /* GDT selector */
|
|
{
|
|
sel &= ~3; /* ignore RPL */
|
|
if (!sel) /* null selector */
|
|
{
|
|
memset( ldtent, 0, sizeof(*ldtent) );
|
|
return TRUE;
|
|
}
|
|
ldtent->BaseLow = 0;
|
|
ldtent->HighWord.Bits.BaseMid = 0;
|
|
ldtent->HighWord.Bits.BaseHi = 0;
|
|
ldtent->LimitLow = 0xffff;
|
|
ldtent->HighWord.Bits.LimitHi = 0xf;
|
|
ldtent->HighWord.Bits.Dpl = 3;
|
|
ldtent->HighWord.Bits.Sys = 0;
|
|
ldtent->HighWord.Bits.Pres = 1;
|
|
ldtent->HighWord.Bits.Granularity = 1;
|
|
ldtent->HighWord.Bits.Default_Big = 1;
|
|
ldtent->HighWord.Bits.Type = 0x12;
|
|
/* it has to be one of the system GDT selectors */
|
|
if (sel == (wine_get_ds() & ~3)) return TRUE;
|
|
if (sel == (wine_get_ss() & ~3)) return TRUE;
|
|
if (sel == (wine_get_cs() & ~3))
|
|
{
|
|
ldtent->HighWord.Bits.Type |= 8; /* code segment */
|
|
return TRUE;
|
|
}
|
|
SetLastError( ERROR_NOACCESS );
|
|
return FALSE;
|
|
}
|
|
|
|
SERVER_START_REQ( get_selector_entry )
|
|
{
|
|
req->handle = hthread;
|
|
req->entry = sel >> __AHSHIFT;
|
|
if ((ret = !wine_server_call_err( req )))
|
|
{
|
|
if (!(reply->flags & WINE_LDT_FLAGS_ALLOCATED))
|
|
{
|
|
SetLastError( ERROR_MR_MID_NOT_FOUND ); /* sic */
|
|
ret = FALSE;
|
|
}
|
|
else
|
|
{
|
|
wine_ldt_set_base( ldtent, (void *)reply->base );
|
|
wine_ldt_set_limit( ldtent, reply->limit );
|
|
wine_ldt_set_flags( ldtent, reply->flags );
|
|
}
|
|
}
|
|
}
|
|
SERVER_END_REQ;
|
|
return ret;
|
|
#else
|
|
SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
|
|
return FALSE;
|
|
#endif
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* SMapLS* (KERNEL32)
|
|
* These functions map linear pointers at [EBP+xxx] to segmented pointers
|
|
* and return them.
|
|
* Win95 uses some kind of alias structs, which it stores in [EBP+x] to
|
|
* unravel them at SUnMapLS. We just store the segmented pointer there.
|
|
*/
|
|
static void
|
|
x_SMapLS_IP_EBP_x(CONTEXT86 *context,int argoff) {
|
|
DWORD val,ptr;
|
|
|
|
val =*(DWORD*)(context->Ebp + argoff);
|
|
if (val<0x10000) {
|
|
ptr=val;
|
|
*(DWORD*)(context->Ebp + argoff) = 0;
|
|
} else {
|
|
ptr = MapLS((LPVOID)val);
|
|
*(DWORD*)(context->Ebp + argoff) = ptr;
|
|
}
|
|
context->Eax = ptr;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* SMapLS_IP_EBP_8 (KERNEL32.@)
|
|
*/
|
|
void WINAPI SMapLS_IP_EBP_8 (CONTEXT86 *context) {x_SMapLS_IP_EBP_x(context, 8);}
|
|
|
|
/***********************************************************************
|
|
* SMapLS_IP_EBP_12 (KERNEL32.@)
|
|
*/
|
|
void WINAPI SMapLS_IP_EBP_12(CONTEXT86 *context) {x_SMapLS_IP_EBP_x(context,12);}
|
|
|
|
/***********************************************************************
|
|
* SMapLS_IP_EBP_16 (KERNEL32.@)
|
|
*/
|
|
void WINAPI SMapLS_IP_EBP_16(CONTEXT86 *context) {x_SMapLS_IP_EBP_x(context,16);}
|
|
|
|
/***********************************************************************
|
|
* SMapLS_IP_EBP_20 (KERNEL32.@)
|
|
*/
|
|
void WINAPI SMapLS_IP_EBP_20(CONTEXT86 *context) {x_SMapLS_IP_EBP_x(context,20);}
|
|
|
|
/***********************************************************************
|
|
* SMapLS_IP_EBP_24 (KERNEL32.@)
|
|
*/
|
|
void WINAPI SMapLS_IP_EBP_24(CONTEXT86 *context) {x_SMapLS_IP_EBP_x(context,24);}
|
|
|
|
/***********************************************************************
|
|
* SMapLS_IP_EBP_28 (KERNEL32.@)
|
|
*/
|
|
void WINAPI SMapLS_IP_EBP_28(CONTEXT86 *context) {x_SMapLS_IP_EBP_x(context,28);}
|
|
|
|
/***********************************************************************
|
|
* SMapLS_IP_EBP_32 (KERNEL32.@)
|
|
*/
|
|
void WINAPI SMapLS_IP_EBP_32(CONTEXT86 *context) {x_SMapLS_IP_EBP_x(context,32);}
|
|
|
|
/***********************************************************************
|
|
* SMapLS_IP_EBP_36 (KERNEL32.@)
|
|
*/
|
|
void WINAPI SMapLS_IP_EBP_36(CONTEXT86 *context) {x_SMapLS_IP_EBP_x(context,36);}
|
|
|
|
/***********************************************************************
|
|
* SMapLS_IP_EBP_40 (KERNEL32.@)
|
|
*/
|
|
void WINAPI SMapLS_IP_EBP_40(CONTEXT86 *context) {x_SMapLS_IP_EBP_x(context,40);}
|
|
|
|
/***********************************************************************
|
|
* SMapLS (KERNEL32.@)
|
|
*/
|
|
void WINAPI SMapLS( CONTEXT86 *context )
|
|
{
|
|
if (HIWORD(context->Eax))
|
|
{
|
|
context->Eax = MapLS( (LPVOID)context->Eax );
|
|
context->Edx = context->Eax;
|
|
} else {
|
|
context->Edx = 0;
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* SUnMapLS (KERNEL32.@)
|
|
*/
|
|
|
|
void WINAPI SUnMapLS( CONTEXT86 *context )
|
|
{
|
|
if (HIWORD(context->Eax)) UnMapLS( (SEGPTR)context->Eax );
|
|
}
|
|
|
|
inline static void x_SUnMapLS_IP_EBP_x(CONTEXT86 *context,int argoff)
|
|
{
|
|
SEGPTR *ptr = (SEGPTR *)(context->Ebp + argoff);
|
|
if (*ptr)
|
|
{
|
|
UnMapLS( *ptr );
|
|
*ptr = 0;
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* SUnMapLS_IP_EBP_8 (KERNEL32.@)
|
|
*/
|
|
void WINAPI SUnMapLS_IP_EBP_8 (CONTEXT86 *context) { x_SUnMapLS_IP_EBP_x(context, 8); }
|
|
|
|
/***********************************************************************
|
|
* SUnMapLS_IP_EBP_12 (KERNEL32.@)
|
|
*/
|
|
void WINAPI SUnMapLS_IP_EBP_12(CONTEXT86 *context) { x_SUnMapLS_IP_EBP_x(context,12); }
|
|
|
|
/***********************************************************************
|
|
* SUnMapLS_IP_EBP_16 (KERNEL32.@)
|
|
*/
|
|
void WINAPI SUnMapLS_IP_EBP_16(CONTEXT86 *context) { x_SUnMapLS_IP_EBP_x(context,16); }
|
|
|
|
/***********************************************************************
|
|
* SUnMapLS_IP_EBP_20 (KERNEL32.@)
|
|
*/
|
|
void WINAPI SUnMapLS_IP_EBP_20(CONTEXT86 *context) { x_SUnMapLS_IP_EBP_x(context,20); }
|
|
|
|
/***********************************************************************
|
|
* SUnMapLS_IP_EBP_24 (KERNEL32.@)
|
|
*/
|
|
void WINAPI SUnMapLS_IP_EBP_24(CONTEXT86 *context) { x_SUnMapLS_IP_EBP_x(context,24); }
|
|
|
|
/***********************************************************************
|
|
* SUnMapLS_IP_EBP_28 (KERNEL32.@)
|
|
*/
|
|
void WINAPI SUnMapLS_IP_EBP_28(CONTEXT86 *context) { x_SUnMapLS_IP_EBP_x(context,28); }
|
|
|
|
/***********************************************************************
|
|
* SUnMapLS_IP_EBP_32 (KERNEL32.@)
|
|
*/
|
|
void WINAPI SUnMapLS_IP_EBP_32(CONTEXT86 *context) { x_SUnMapLS_IP_EBP_x(context,32); }
|
|
|
|
/***********************************************************************
|
|
* SUnMapLS_IP_EBP_36 (KERNEL32.@)
|
|
*/
|
|
void WINAPI SUnMapLS_IP_EBP_36(CONTEXT86 *context) { x_SUnMapLS_IP_EBP_x(context,36); }
|
|
|
|
/***********************************************************************
|
|
* SUnMapLS_IP_EBP_40 (KERNEL32.@)
|
|
*/
|
|
void WINAPI SUnMapLS_IP_EBP_40(CONTEXT86 *context) { x_SUnMapLS_IP_EBP_x(context,40); }
|
|
|
|
/**********************************************************************
|
|
* AllocMappedBuffer (KERNEL32.38)
|
|
*
|
|
* This is a undocumented KERNEL32 function that
|
|
* SMapLS's a GlobalAlloc'ed buffer.
|
|
*
|
|
* Input: EDI register: size of buffer to allocate
|
|
* Output: EDI register: pointer to buffer
|
|
*
|
|
* Note: The buffer is preceded by 8 bytes:
|
|
* ...
|
|
* edi+0 buffer
|
|
* edi-4 SEGPTR to buffer
|
|
* edi-8 some magic Win95 needs for SUnMapLS
|
|
* (we use it for the memory handle)
|
|
*
|
|
* The SEGPTR is used by the caller!
|
|
*/
|
|
|
|
void WINAPI AllocMappedBuffer( CONTEXT86 *context )
|
|
{
|
|
HGLOBAL handle = GlobalAlloc(0, context->Edi + 8);
|
|
DWORD *buffer = (DWORD *)GlobalLock(handle);
|
|
SEGPTR ptr = 0;
|
|
|
|
if (buffer)
|
|
if (!(ptr = MapLS(buffer + 2)))
|
|
{
|
|
GlobalUnlock(handle);
|
|
GlobalFree(handle);
|
|
}
|
|
|
|
if (!ptr)
|
|
context->Eax = context->Edi = 0;
|
|
else
|
|
{
|
|
buffer[0] = (DWORD)handle;
|
|
buffer[1] = ptr;
|
|
|
|
context->Eax = (DWORD) ptr;
|
|
context->Edi = (DWORD)(buffer + 2);
|
|
}
|
|
}
|
|
|
|
/**********************************************************************
|
|
* FreeMappedBuffer (KERNEL32.39)
|
|
*
|
|
* Free a buffer allocated by AllocMappedBuffer
|
|
*
|
|
* Input: EDI register: pointer to buffer
|
|
*/
|
|
|
|
void WINAPI FreeMappedBuffer( CONTEXT86 *context )
|
|
{
|
|
if (context->Edi)
|
|
{
|
|
DWORD *buffer = (DWORD *)context->Edi - 2;
|
|
|
|
UnMapLS(buffer[1]);
|
|
|
|
GlobalUnlock((HGLOBAL)buffer[0]);
|
|
GlobalFree((HGLOBAL)buffer[0]);
|
|
}
|
|
}
|