On-line справка по Win32 API

БЕСПЛАТНАЯ ежедневная online лотерея! Выигрывай каждый день БЕСПЛАТНО!

A-B-C-D-E-F-G-H-I-J-K-L-M-N-O-P-Q-R-S-T-U-V-W-X-Y-Z | Скачать

Using Shared Memory in a Dynamic-Link Library

This section shows how the DLL entry-point function can use a file-mapping object to set up memory that can be shared by processes that load the DLL. The shared DLL memory persists only as long as the DLL is loaded.

The example uses file mapping to map a block of named shared memory into the virtual address space of each process that loads the DLL. To do this, the entry-point function must:

1. Call the CreateFileMapping function to get a handle to a file-mapping object. The first process that loads the DLL creates the file-mapping object. Subsequent processes open a handle of the existing object. For more information, see Creating a File-Mapping Object.
2. Call the MapViewOfFile function to map a view into the virtual address space. This enables the process to access the shared memory. For more information, see Creating a File View.

// File: DLLSHMEM.C.
// The DLL entry-point function sets up shared memory using
// a named file-mapping object.

#include
#include

#define SHMEMSIZE 4096

static LPVOID lpvMem = NULL; // pointer to shared memory

BOOL DllEntryPoint(HINSTANCE hinstDLL, // DLL module handle
DWORD fdwReason, // reason called
LPVOID lpvReserved) // reserved
{
HANDLE hMapObject = NULL; // handle to file mapping

BOOL fInit, fIgnore;

switch (fdwReason)
{
// The DLL is loading due to process
// initialization or a call to LoadLibrary.

case DLL_PROCESS_ATTACH:

// Create a named file mapping object.

hMapObject = CreateFileMapping(
(HANDLE) 0xFFFFFFFF, // use paging file
NULL, // no security attributes
PAGE_READWRITE, // read/write access

0, // size: high 32-bits
SHMEMSIZE, // size: low 32-bits
"dllmemfilemap"); // name of map object
if (hMapObject == NULL)
return FALSE;

// The first process to attach initializes memory.

fInit = (GetLastError() != ERROR_ALREADY_EXISTS);

// Get a pointer to the file-mapped shared memory.

lpvMem = MapViewOfFile(

hMapObject, // object to map view of
FILE_MAP_WRITE, // read/write access
0, // high offset: map from
0, // low offset: beginning
0); // default: map entire file
if (lpvMem == NULL)
return FALSE;

// Initialize memory if this is the first process.

if (fInit)
memset(lpvMem, '\0', SHMEMSIZE);

break;

// The attached process creates a new thread.

case DLL_THREAD_ATTACH:
break;

// The thread of the attached process terminates.

case DLL_THREAD_DETACH:
break;

// The DLL is unloading from a process due to
// process termination or a call to FreeLibrary.

case DLL_PROCESS_DETACH:

// Unmap shared memory from the process's address space.

fIgnore = UnmapViewOfFile(lpvMem);

// Close the process's handle to the file-mapping object.

fIgnore = CloseHandle(hMapObject);

break;

default:
break;
}

return TRUE;
UNREFERENCED_PARAMETER(hinstDLL);
UNREFERENCED_PARAMETER(lpvReserved);
}

// SetSharedMem sets the contents of shared memory.

VOID SetSharedMem(LPTSTR lpszBuf)
{
LPTSTR lpszTmp;

// Get the address of the shared memory block.

lpszTmp = (LPTSTR) lpvMem;

// Copy the null-terminated string into shared memory.

while (*lpszBuf)
*lpszTmp++ = *lpszBuf++;
*lpszTmp = '\0';
}

// GetSharedMem gets the contents of shared memory.

VOID GetSharedMem(LPTSTR lpszBuf, DWORD cchSize)
{
LPTSTR lpszTmp;

// Get the address of the shared memory block.

lpszTmp = (LPTSTR) lpvMem;

// Copy from shared memory into the caller's buffer.

while (*lpszTmp && --cchSize)
*lpszBuf++ = *lpszTmp++;
*lpszBuf = '\0';
}

Note that the shared memory can be mapped to a different address in each process. For this reason, each process has its own instance of the lpvMem parameter, which is declared as a global variable so that it is available to all DLL functions. The example assumes that the DLL global data is not shared, so each process that loads the DLL has its own instance of lpvMem.
In this example, the shared memory is released when the last handle of the file-mapping object is closed. To create persistent shared memory, a DLL can create a detached process (see CreateProcess) when the DLL is first loaded. If this detached process uses the DLL and does not terminate, it has a handle of the file-mapping object that prevents the shared memory from being released.

Пригласи друзей и счет твоего мобильника всегда будет положительным!

Пригласи друзей и счет твоего мобильника всегда будет положительным!

Использование Коллективной Памяти в Библиотеке Dynamic-Link

Эта секция показывает как вход-точка функции DLL может использовать файловое распределение объекта против установившее память, которая может быть распространена процессами, которые загружают DLL. Коллективная память DLL упорствует только так же долго (длиной) как DLL загружен.

Пример использует файл, отображающий, чтобы отображать блока поименованной коллективной памяти в виртуальное пространство адреса каждого процесса, которое загружает DLL. Для того, чтобы делать это, вход-точка функции должен:

1. Назовите функцию CreateFileMapping, чтобы получать ручку в файловое распределение объекта. Первый процесс, который загружает DLL создает файловое распределение объекта. Последующие процессы открывают ручку существующего объекта. Более подробно, смотри Создавая Объект File-Mapping.
2. Назовите функцию MapViewOfFile, чтобы отображать вид в виртуальное пространство адреса. Это позволяет процесс, чтобы иметь доступ к коллективной памяти. Более подробно, смотри Создавая Файловый Вид.

// Файл: DLLSHMEM.C.
// Вход-точка функции DLL устанавливают коллективное использование / память/ a называл файловое распределение объекта.

#include #include

#define SHMEMSIZE 4096

статический LPVOID lpvMem = НЕДЕЙСТВИТЕЛЬНЫЙ; // указатель на распространившее память

BOOL DllEntryPoint(HINSTANCE hinstDLL, // МОДУЛЬНАЯ ручка DLL DWORD fdwReason, // причина была названа LPVOID lpvReserved) // зарезервированное
{
РУЧКА hMapObject = НЕДЕЙСТВИТЕЛЬНЫЙ; // ручка в файловое распределение

BOOL fInit, fIgnore;

ключ (fdwReason)
{
// DLL Загружается из-за процесса // инициализация или вызов на LoadLibrary.

случай DLL_PROCESS_ATTACH:

// Создайте поименованный файл, отображающий объект.

hMapObject = CreateFileMapping( (РУЧКА) 0xFFFFFFFF, // подкачка использования файловая НЕДЕЙСТВИТЕЛЬНАЯ, // никакие атрибуты безопасности PAGE_READWRITE, // прочитавшее/доступ записи

0, // размер: высокие 32- биты SHMEMSIZE, // размер: низкие 32- биты "dllmemfilemap"); // имя объекта карты если (hMapObject == НЕДЕЙСТВИТЕЛЬНЫЙ) обратная ЛОЖЬ;

// Первый процесс, чтобы подключать инициализирует память.

fInit = (GetLastError() != ERROR_ALREADY_EXISTS);

// Получите указатель в отображенный файл распространивший память.

lpvMem = MapViewOfFile(

hMapObject, // ОБЪЕКТ против вида карты FILE_MAP_WRITE, // прочитавшее/доступ записи 0, // высокая компенсация: карта с 0, // низкая компенсация: начало 0); // невыполнение: целый файл карты если (lpvMem == НЕДЕЙСТВИТЕЛЬНЫЙ) обратная ЛОЖЬ;

// Инициализируйте память если это - первый процесс.

если (fInit)
memset(lpvMem, '\0', SHMEMSIZE);

прерывание;

// Прилагаемый процесс создает новую резьбу.

случай DLL_THREAD_ATTACH: прерывание;

// Резьба прилагаемого процесса завершается.

случай DLL_THREAD_DETACH: прерывание;

// DLL Разгружается из процесса из-за // завершения процесса или вызов на FreeLibrary.

случай DLL_PROCESS_DETACH:

// Unmap Распространял память из пространства адреса процесса.

fIgnore = UnmapViewOfFile(lpvMem);

// Закрытие ручка процесса в файловое распределение объекта.

fIgnore = CloseHandle(hMapObject);

прерывание;

невыполнение: прерывание;
}

возвращайтесь ВЕРНО;
UNREFERENCED_PARAMETER(hinstDLL);
UNREFERENCED_PARAMETER(lpvReserved);
}

// SetSharedMem УСТАНАВЛИВАЕТ содержание коллективной памяти.

ПУСТОТА SetSharedMem(LPTSTR lpszBuf)
{
LPTSTR lpszTmp;

// Получите адрес коллективного блока памяти.

lpszTmp = (LPTSTR) lpvMem;

// Скопируйте недействительный расторгнутую строку в коллективную память.

пока (*lpszBuf) *lpszTmp++ = *lpszBuf++;
*lpszTmp = '\0;
}

// GetSharedMem ПОЛУЧАЕТ содержание коллективной памяти.

ПУСТОТА GetSharedMem(LPTSTR lpszBuf, DWORD cchSize)
{
LPTSTR lpszTmp;

// Получите адрес коллективного блока памяти.

lpszTmp = (LPTSTR) lpvMem;

// Копия из коллективной памяти в буфер вызывающего оператора.

пока (*lpszTmp && --cchSize) *lpszBuf++ = *lpszTmp++;
*lpszBuf = '\0;
}

Отметьте, что коллективная память может быть отображена в другой адрес в каждом процессе. По этой причине, каждый процесс имеет собственный пример параметра lpvMem, который объявлен как глобальная переменная чтобы доступно во всех функциях DLL. Пример допускает что глобальные данные DLL не распространены, так что каждый процесс, который загружает DLL имеет собственный пример lpvMem.
В этом примере, коллективная память выпущена когда последняя ручка файлового распределения объекта закрыта. Для того, чтобы создавать устойчивую коллективную память, DLL может создать отделенный процесс (смотри CreateProcess) когда DLL сначала загружен. Если этот отделенный процесс использует DLL и не завершается, у него есть ручка файлового распределения объекта, что предохраняет коллективную память от выпущенное.

Используются технологии uCoz