ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

ntdll: Reimplement local atom tables in user space. 

Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Alexandre Julliard 2021-02-16 11:01:25 +01:00
parent e830975806
commit e941079126
3 changed files with 219 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

308
dlls/ntdll/atom.c
View File

@ -1,7 +1,7 @@
/* /*
* Atom table functions * Atom table functions
* *
* Copyright 1993, 1994, 1995 Alexandre Julliard * Copyright 1993, 1994, 1995, 2021 Alexandre Julliard
* Copyright 2004,2005 Eric Pouech * Copyright 2004,2005 Eric Pouech
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
@ -37,7 +37,88 @@
WINE_DEFAULT_DEBUG_CHANNEL(atom); WINE_DEFAULT_DEBUG_CHANNEL(atom);
#define MAX_ATOM_LEN 255 #define MAX_ATOM_LEN 255
#define MAX_ATOMS 0x4000
#define IS_INTATOM(x) (((ULONG_PTR)(x) >> 16) == 0) #define IS_INTATOM(x) (((ULONG_PTR)(x) >> 16) == 0)
#define TABLE_SIGNATURE 0x6d6f7441 /* 'Atom' */
#define HASH_SIZE 37
#define MIN_HASH_SIZE 4
#define MAX_HASH_SIZE 0x200
struct atom_handle
{
RTL_HANDLE hdr;
RTL_ATOM_TABLE_ENTRY *entry;
};
static NTSTATUS lock_atom_table( RTL_ATOM_TABLE table )
{
if (!table) return STATUS_INVALID_PARAMETER;
if (table->Signature != TABLE_SIGNATURE) return STATUS_INVALID_PARAMETER;
RtlEnterCriticalSection( &table->CriticalSection );
return STATUS_SUCCESS;
}
static void unlock_atom_table( RTL_ATOM_TABLE table )
{
RtlLeaveCriticalSection( &table->CriticalSection );
}
static ULONG hash_str( RTL_ATOM_TABLE table, const WCHAR *name, ULONG len )
{
UNICODE_STRING str = { len * sizeof(WCHAR), len * sizeof(WCHAR), (WCHAR *)name };
ULONG hash;
RtlHashUnicodeString( &str, TRUE, HASH_STRING_ALGORITHM_X65599, &hash );
return hash % table->NumberOfBuckets;
}
static RTL_ATOM_TABLE_ENTRY *find_entry( RTL_ATOM_TABLE table, const WCHAR *name, ULONG len, ULONG hash )
{
RTL_ATOM_TABLE_ENTRY *entry = table->Buckets[hash];
while (entry)
{
if (!RtlCompareUnicodeStrings( entry->Name, entry->NameLength, name, len, TRUE )) break;
entry = entry->HashLink;
}
return entry;
}
static NTSTATUS add_atom( RTL_ATOM_TABLE table, const WCHAR *name, ULONG len, RTL_ATOM *atom )
{
RTL_ATOM_TABLE_ENTRY *entry;
struct atom_handle *handle;
ULONG index, hash = hash_str( table, name, len );
if ((entry = find_entry( table, name, len, hash ))) /* exists already */
{
entry->ReferenceCount++;
*atom = entry->Atom;
return STATUS_SUCCESS;
}
if (!(handle = (struct atom_handle *)RtlAllocateHandle( &table->HandleTable, &index )))
return STATUS_NO_MEMORY;
if (!(entry = RtlAllocateHeap( GetProcessHeap(), 0, offsetof( RTL_ATOM_TABLE_ENTRY, Name[len] ) )))
{
RtlFreeHandle( &table->HandleTable, &handle->hdr );
return STATUS_NO_MEMORY;
}
entry->HandleIndex = index;
entry->Atom = MAXINTATOM + index;
entry->ReferenceCount = 1;
entry->Flags = 0;
entry->NameLength = len;
entry->HashLink = table->Buckets[hash];
memcpy( entry->Name, name, len * sizeof(WCHAR) );
handle->hdr.Next = (RTL_HANDLE *)1;
table->Buckets[hash] = entry;
handle->entry = entry;
*atom = entry->Atom;
return STATUS_SUCCESS;
}
/****************************************************************** /******************************************************************
* is_integral_atom * is_integral_atom
@ -78,20 +159,30 @@ done:
*/ */
NTSTATUS WINAPI RtlDeleteAtomFromAtomTable( RTL_ATOM_TABLE table, RTL_ATOM atom ) NTSTATUS WINAPI RtlDeleteAtomFromAtomTable( RTL_ATOM_TABLE table, RTL_ATOM atom )
{ {
NTSTATUS status; NTSTATUS status;
struct atom_handle *handle;
TRACE( "%p %x\n", table, atom ); if ((status = lock_atom_table( table ))) return status;
if (!table) status = STATUS_INVALID_PARAMETER;
else if (atom >= MAXINTATOM && RtlIsValidIndexHandle( &table->HandleTable, atom - MAXINTATOM,
(RTL_HANDLE **)&handle ))
{ {
SERVER_START_REQ( delete_atom ) if (handle->entry->Flags) status = STATUS_WAS_LOCKED;
else if (!--handle->entry->ReferenceCount)
{ {
req->atom = atom; ULONG hash = hash_str( table, handle->entry->Name, handle->entry->NameLength );
req->table = wine_server_obj_handle( table ); RTL_ATOM_TABLE_ENTRY **ptr = &table->Buckets[hash];
status = wine_server_call( req );
while (*ptr != handle->entry) ptr = &(*ptr)->HashLink;
*ptr = (*ptr)->HashLink;
RtlFreeHeap( GetProcessHeap(), 0, handle->entry );
RtlFreeHandle( &table->HandleTable, &handle->hdr );
} }
SERVER_END_REQ;
} }
else status = STATUS_INVALID_HANDLE;
unlock_atom_table( table );
TRACE( "%p %x\n", table, atom );
return status; return status;
} }
@ -119,46 +210,43 @@ static ULONG integral_atom_name(WCHAR* buffer, ULONG len, RTL_ATOM atom)
NTSTATUS WINAPI RtlQueryAtomInAtomTable( RTL_ATOM_TABLE table, RTL_ATOM atom, ULONG* ref, NTSTATUS WINAPI RtlQueryAtomInAtomTable( RTL_ATOM_TABLE table, RTL_ATOM atom, ULONG* ref,
ULONG* pin, WCHAR* name, ULONG* len ) ULONG* pin, WCHAR* name, ULONG* len )
{ {
NTSTATUS status = STATUS_SUCCESS; NTSTATUS status;
DWORD wlen = 0; struct atom_handle *handle;
ULONG wlen = 0;
if (!table) status = STATUS_INVALID_PARAMETER; if (!atom) return STATUS_INVALID_PARAMETER;
else if (atom < MAXINTATOM) if ((status = lock_atom_table( table ))) return status;
if (atom < MAXINTATOM)
{ {
if (!atom) return STATUS_INVALID_PARAMETER;
if (len) wlen = integral_atom_name( name, *len, atom); if (len) wlen = integral_atom_name( name, *len, atom);
if (ref) *ref = 1; if (ref) *ref = 1;
if (pin) *pin = 1; if (pin) *pin = 1;
} }
else else if (RtlIsValidIndexHandle( &table->HandleTable, atom - MAXINTATOM, (RTL_HANDLE **)&handle ))
{ {
SERVER_START_REQ( get_atom_information ) wlen = handle->entry->NameLength * sizeof(WCHAR);
{ if (ref) *ref = handle->entry->ReferenceCount;
req->atom = atom; if (pin) *pin = handle->entry->Flags;
req->table = wine_server_obj_handle( table ); if (len && *len)
if (len && *len && name)
wine_server_set_reply( req, name, *len );
status = wine_server_call( req );
if (status == STATUS_SUCCESS)
{
wlen = reply->total;
if (ref) *ref = reply->count;
if (pin) *pin = reply->pinned;
}
}
SERVER_END_REQ;
}
if (status == STATUS_SUCCESS && len)
{
if (*len)
{ {
wlen = min( *len - sizeof(WCHAR), wlen ); wlen = min( *len - sizeof(WCHAR), wlen );
if (name) name[wlen / sizeof(WCHAR)] = 0; if (name)
{
memcpy( name, handle->entry->Name, wlen );
name[wlen / sizeof(WCHAR)] = 0;
}
} }
else status = STATUS_BUFFER_TOO_SMALL; }
else status = STATUS_INVALID_HANDLE;
unlock_atom_table( table );
if (status == STATUS_SUCCESS && len)
{
if (!*len) status = STATUS_BUFFER_TOO_SMALL;
*len = wlen; *len = wlen;
} }
TRACE( "%p %x -> %s (%x)\n", TRACE( "%p %x -> %s (%x)\n",
table, atom, len ? debugstr_wn(name, wlen / sizeof(WCHAR)) : "(null)", status ); table, atom, len ? debugstr_wn(name, wlen / sizeof(WCHAR)) : "(null)", status );
return status; return status;
@ -167,26 +255,25 @@ NTSTATUS WINAPI RtlQueryAtomInAtomTable( RTL_ATOM_TABLE table, RTL_ATOM atom, UL
/****************************************************************** /******************************************************************
* RtlCreateAtomTable (NTDLL.@) * RtlCreateAtomTable (NTDLL.@)
*/ */
NTSTATUS WINAPI RtlCreateAtomTable( ULONG size, RTL_ATOM_TABLE* table ) NTSTATUS WINAPI RtlCreateAtomTable( ULONG size, RTL_ATOM_TABLE *ret_table )
{ {
NTSTATUS status; RTL_ATOM_TABLE table;
if (*table) if (*ret_table) return size ? STATUS_INVALID_PARAMETER : STATUS_SUCCESS;
{
if (size) status = STATUS_INVALID_PARAMETER; if ((size < MIN_HASH_SIZE) || (size > MAX_HASH_SIZE)) size = HASH_SIZE;
else status = STATUS_SUCCESS;
} if (!(table = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
else offsetof( struct _RTL_ATOM_TABLE, Buckets[size] ))))
{ return STATUS_NO_MEMORY;
SERVER_START_REQ( init_atom_table )
{ table->Signature = TABLE_SIGNATURE;
req->entries = size; table->NumberOfBuckets = size;
status = wine_server_call( req );
*table = wine_server_ptr_handle( reply->table ); RtlInitializeCriticalSection( &table->CriticalSection );
} RtlInitializeHandleTable( MAX_ATOMS, sizeof(struct atom_handle), &table->HandleTable );
SERVER_END_REQ; *ret_table = table;
} return STATUS_SUCCESS;
return status;
} }
/****************************************************************** /******************************************************************
@ -194,8 +281,12 @@ NTSTATUS WINAPI RtlCreateAtomTable( ULONG size, RTL_ATOM_TABLE* table )
*/ */
NTSTATUS WINAPI RtlDestroyAtomTable( RTL_ATOM_TABLE table ) NTSTATUS WINAPI RtlDestroyAtomTable( RTL_ATOM_TABLE table )
{ {
if (!table) return STATUS_INVALID_PARAMETER; if (!table || table->Signature != TABLE_SIGNATURE) return STATUS_INVALID_PARAMETER;
return NtClose( table ); RtlDestroyHandleTable( &table->HandleTable );
RtlDeleteCriticalSection( &table->CriticalSection );
table->Signature = 0;
RtlFreeHeap( GetProcessHeap(), 0, table );
return STATUS_SUCCESS;
} }
/****************************************************************** /******************************************************************
@ -203,28 +294,16 @@ NTSTATUS WINAPI RtlDestroyAtomTable( RTL_ATOM_TABLE table )
*/ */
NTSTATUS WINAPI RtlAddAtomToAtomTable( RTL_ATOM_TABLE table, const WCHAR* name, RTL_ATOM* atom ) NTSTATUS WINAPI RtlAddAtomToAtomTable( RTL_ATOM_TABLE table, const WCHAR* name, RTL_ATOM* atom )
{ {
NTSTATUS status; NTSTATUS status;
size_t len;
if (!table) status = STATUS_INVALID_PARAMETER; if ((status = lock_atom_table( table ))) return status;
else
{
size_t len = IS_INTATOM(name) ? 0 : wcslen(name);
status = is_integral_atom( name, len, atom );
if (status == STATUS_MORE_ENTRIES)
{
SERVER_START_REQ( add_atom )
{
wine_server_add_data( req, name, len * sizeof(WCHAR) );
req->table = wine_server_obj_handle( table );
status = wine_server_call( req );
*atom = reply->atom;
}
SERVER_END_REQ;
}
}
TRACE( "%p %s -> %x\n",
table, debugstr_w(name), status == STATUS_SUCCESS ? *atom : 0 );
len = IS_INTATOM( name ) ? 0 : wcslen( name );
status = is_integral_atom( name, len, atom );
if (status == STATUS_MORE_ENTRIES) status = add_atom( table, name, len, atom );
unlock_atom_table( table );
TRACE( "%p %s -> %x\n", table, debugstr_w(name), status == STATUS_SUCCESS ? *atom : 0 );
return status; return status;
} }
@ -233,25 +312,24 @@ NTSTATUS WINAPI RtlAddAtomToAtomTable( RTL_ATOM_TABLE table, const WCHAR* name,
*/ */
NTSTATUS WINAPI RtlLookupAtomInAtomTable( RTL_ATOM_TABLE table, const WCHAR* name, RTL_ATOM* atom ) NTSTATUS WINAPI RtlLookupAtomInAtomTable( RTL_ATOM_TABLE table, const WCHAR* name, RTL_ATOM* atom )
{ {
NTSTATUS status; RTL_ATOM_TABLE_ENTRY *entry;
NTSTATUS status;
ULONG len;
if (!table) status = STATUS_INVALID_PARAMETER; if ((status = lock_atom_table( table ))) return status;
else
len = IS_INTATOM(name) ? 0 : wcslen(name);
status = is_integral_atom( name, len, atom );
if (status == STATUS_MORE_ENTRIES)
{ {
size_t len = IS_INTATOM(name) ? 0 : wcslen(name); if ((entry = find_entry( table, name, len, hash_str( table, name, len ))))
status = is_integral_atom( name, len, atom );
if (status == STATUS_MORE_ENTRIES)
{ {
SERVER_START_REQ( find_atom ) *atom = entry->Atom;
{ status = STATUS_SUCCESS;
wine_server_add_data( req, name, len * sizeof(WCHAR) );
req->table = wine_server_obj_handle( table );
status = wine_server_call( req );
*atom = reply->atom;
}
SERVER_END_REQ;
} }
else status = STATUS_OBJECT_NAME_NOT_FOUND;
} }
unlock_atom_table( table );
TRACE( "%p %s -> %x\n", TRACE( "%p %s -> %x\n",
table, debugstr_w(name), status == STATUS_SUCCESS ? *atom : 0 ); table, debugstr_w(name), status == STATUS_SUCCESS ? *atom : 0 );
return status; return status;
@ -262,20 +340,31 @@ NTSTATUS WINAPI RtlLookupAtomInAtomTable( RTL_ATOM_TABLE table, const WCHAR* nam
*/ */
NTSTATUS WINAPI RtlEmptyAtomTable( RTL_ATOM_TABLE table, BOOLEAN delete_pinned ) NTSTATUS WINAPI RtlEmptyAtomTable( RTL_ATOM_TABLE table, BOOLEAN delete_pinned )
{ {
NTSTATUS status; struct atom_handle *handle;
NTSTATUS status;
ULONG i;
if (!table) status = STATUS_INVALID_PARAMETER; if ((status = lock_atom_table( table ))) return status;
else
for (i = 0; i < table->NumberOfBuckets; i++)
{ {
SERVER_START_REQ( empty_atom_table ) RTL_ATOM_TABLE_ENTRY **ptr = &table->Buckets[i];
while (*ptr)
{ {
req->table = wine_server_obj_handle( table ); if (!delete_pinned && (*ptr)->Flags) ptr = &(*ptr)->HashLink;
req->if_pinned = delete_pinned; else
status = wine_server_call( req ); {
RTL_ATOM_TABLE_ENTRY *entry = *ptr;
*ptr = entry->HashLink;
if (RtlIsValidIndexHandle( &table->HandleTable, entry->HandleIndex,
(RTL_HANDLE **)&handle ))
RtlFreeHandle( &table->HandleTable, &handle->hdr );
RtlFreeHeap( GetProcessHeap(), 0, entry );
}
} }
SERVER_END_REQ;
} }
return status; unlock_atom_table( table );
return STATUS_SUCCESS;
} }
/****************************************************************** /******************************************************************
@ -283,19 +372,16 @@ NTSTATUS WINAPI RtlEmptyAtomTable( RTL_ATOM_TABLE table, BOOLEAN delete_pinned )
*/ */
NTSTATUS WINAPI RtlPinAtomInAtomTable( RTL_ATOM_TABLE table, RTL_ATOM atom ) NTSTATUS WINAPI RtlPinAtomInAtomTable( RTL_ATOM_TABLE table, RTL_ATOM atom )
{ {
struct atom_handle *handle;
NTSTATUS status; NTSTATUS status;
if (!table) return STATUS_INVALID_PARAMETER; if ((status = lock_atom_table( table ))) return status;
if (atom < MAXINTATOM) return STATUS_SUCCESS;
SERVER_START_REQ( set_atom_information ) if (atom >= MAXINTATOM && RtlIsValidIndexHandle( &table->HandleTable, atom - MAXINTATOM,
(RTL_HANDLE **)&handle ))
{ {
req->table = wine_server_obj_handle( table ); handle->entry->Flags = 1;
req->atom = atom;
req->pinned = TRUE;
status = wine_server_call( req );
} }
SERVER_END_REQ; unlock_atom_table( table );
return STATUS_SUCCESS;
return status;
} }

2
dlls/ntdll/tests/atom.c
View File

@ -153,6 +153,8 @@ static void test_NtAtom(void)
ok(!res, "We're unable to create an atom table with a valid table size retval: %x\n", res); ok(!res, "We're unable to create an atom table with a valid table size retval: %x\n", res);
if (!res) if (!res)
{ {
ok( *(DWORD *)AtomTable == 0x6d6f7441, "wrong signature %x\n", *(DWORD *)AtomTable );
res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom1); res = pRtlAddAtomToAtomTable(AtomTable, testAtom1, &Atom1);
ok(!res, "We were unable to add a simple atom to the atom table, retval: %x\n", res); ok(!res, "We were unable to add a simple atom to the atom table, retval: %x\n", res);

26
include/winternl.h
View File

@ -2154,12 +2154,6 @@ typedef struct _PORT_MESSAGE_HEADER {
typedef unsigned short RTL_ATOM, *PRTL_ATOM; typedef unsigned short RTL_ATOM, *PRTL_ATOM;
/* Wine doesn't implement atom table as NT does:
* - in NT, atom tables are user space tables, which ntdll directly accesses
* - on Wine, (even local) atom tables are wineserver objects, hence a HANDLE
*/
typedef struct atom_table *RTL_ATOM_TABLE, **PRTL_ATOM_TABLE;
typedef enum _ATOM_INFORMATION_CLASS { typedef enum _ATOM_INFORMATION_CLASS {
AtomBasicInformation = 0, AtomBasicInformation = 0,
AtomTableInformation = 1, AtomTableInformation = 1,
@ -2190,6 +2184,26 @@ typedef struct _RTL_HANDLE_TABLE
PVOID MaxHandle; /* 0x1c */ PVOID MaxHandle; /* 0x1c */
} RTL_HANDLE_TABLE; } RTL_HANDLE_TABLE;
typedef struct _RTL_ATOM_TABLE_ENTRY
{
struct _RTL_ATOM_TABLE_ENTRY *HashLink;
WORD HandleIndex;
WORD Atom;
WORD ReferenceCount;
UCHAR Flags;
UCHAR NameLength;
WCHAR Name[1];
} RTL_ATOM_TABLE_ENTRY, *PRTL_ATOM_TABLE_ENTRY;
typedef struct _RTL_ATOM_TABLE
{
ULONG Signature;
RTL_CRITICAL_SECTION CriticalSection;
RTL_HANDLE_TABLE HandleTable;
ULONG NumberOfBuckets;
RTL_ATOM_TABLE_ENTRY *Buckets[1];
} *RTL_ATOM_TABLE, **PRTL_ATOM_TABLE;
/*********************************************************************** /***********************************************************************
* Defines * Defines
*/ */