271 lines
7.3 KiB
C++
271 lines
7.3 KiB
C++
/* shared.cc: shared data area support.
|
|
|
|
Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
|
|
|
|
This file is part of Cygwin.
|
|
|
|
This software is a copyrighted work licensed under the terms of the
|
|
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
|
|
details. */
|
|
|
|
#include "winsup.h"
|
|
#include <unistd.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <grp.h>
|
|
#include <pwd.h>
|
|
#include "pinfo.h"
|
|
#include "security.h"
|
|
#include "fhandler.h"
|
|
#include "path.h"
|
|
#include "dtable.h"
|
|
#include "cygerrno.h"
|
|
#include "cygheap.h"
|
|
#include "heap.h"
|
|
#include "shared_info_magic.h"
|
|
#include "registry.h"
|
|
#include "cygwin_version.h"
|
|
#include "child_info.h"
|
|
|
|
shared_info NO_COPY *cygwin_shared;
|
|
mount_info NO_COPY *mount_table;
|
|
HANDLE NO_COPY cygwin_mount_h;
|
|
|
|
char * __stdcall
|
|
shared_name (char *ret_buf, const char *str, int num)
|
|
{
|
|
extern bool _cygwin_testing;
|
|
|
|
__small_sprintf (ret_buf, "%s%s.%s.%d",
|
|
wincap.has_terminal_services () ? "Global\\" : "",
|
|
cygwin_version.shared_id, str, num);
|
|
if (_cygwin_testing)
|
|
strcat (ret_buf, cygwin_version.dll_build_date);
|
|
return ret_buf;
|
|
}
|
|
|
|
#define page_const (65535)
|
|
#define pround(n) (((size_t) (n) + page_const) & ~page_const)
|
|
|
|
static char *offsets[] =
|
|
{
|
|
(char *) cygwin_shared_address,
|
|
(char *) cygwin_shared_address
|
|
+ pround (sizeof (shared_info)),
|
|
(char *) cygwin_shared_address
|
|
+ pround (sizeof (shared_info))
|
|
+ pround (sizeof (mount_info)),
|
|
(char *) cygwin_shared_address
|
|
+ pround (sizeof (shared_info))
|
|
+ pround (sizeof (mount_info))
|
|
+ pround (sizeof (console_state)),
|
|
(char *) cygwin_shared_address
|
|
+ pround (sizeof (shared_info))
|
|
+ pround (sizeof (mount_info))
|
|
+ pround (sizeof (console_state))
|
|
+ pround (sizeof (_pinfo))
|
|
};
|
|
|
|
void * __stdcall
|
|
open_shared (const char *name, int n, HANDLE &shared_h, DWORD size, shared_locations m)
|
|
{
|
|
void *shared;
|
|
|
|
void *addr;
|
|
if (!wincap.needs_memory_protection ())
|
|
addr = NULL;
|
|
else
|
|
{
|
|
addr = offsets[m];
|
|
(void) VirtualFree (addr, 0, MEM_RELEASE);
|
|
}
|
|
|
|
if (!size)
|
|
return addr;
|
|
|
|
if (!shared_h)
|
|
{
|
|
char *mapname;
|
|
char map_buf[MAX_PATH];
|
|
if (!name)
|
|
mapname = NULL;
|
|
else
|
|
{
|
|
mapname = shared_name (map_buf, name, n);
|
|
shared_h = OpenFileMappingA (FILE_MAP_READ | FILE_MAP_WRITE,
|
|
TRUE, mapname);
|
|
}
|
|
if (!shared_h &&
|
|
!(shared_h = CreateFileMapping (INVALID_HANDLE_VALUE, &sec_all,
|
|
PAGE_READWRITE, 0, size, mapname)))
|
|
api_fatal ("CreateFileMapping, %E. Terminating.");
|
|
}
|
|
|
|
shared = (shared_info *)
|
|
MapViewOfFileEx (shared_h, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0, addr);
|
|
|
|
if (!shared)
|
|
{
|
|
/* Probably win95, so try without specifying the address. */
|
|
shared = (shared_info *) MapViewOfFileEx (shared_h,
|
|
FILE_MAP_READ|FILE_MAP_WRITE,
|
|
0, 0, 0, 0);
|
|
#ifdef DEBUGGING
|
|
if (wincap.is_winnt ())
|
|
system_printf ("relocating shared object %s(%d) from %p to %p on Windows NT", name, n, addr, shared);
|
|
#endif
|
|
}
|
|
|
|
if (!shared)
|
|
api_fatal ("MapViewOfFileEx '%s'(%p), %E. Terminating.", name, shared_h);
|
|
|
|
if (m == SH_CYGWIN_SHARED && wincap.needs_memory_protection ())
|
|
{
|
|
unsigned delta = (char *) shared - offsets[0];
|
|
offsets[0] = (char *) shared;
|
|
for (int i = SH_CYGWIN_SHARED + 1; i < SH_TOTAL_SIZE; i++)
|
|
{
|
|
unsigned size = offsets[i + 1] - offsets[i];
|
|
offsets[i] += delta;
|
|
if (!VirtualAlloc (offsets[i], size, MEM_RESERVE, PAGE_NOACCESS))
|
|
continue; /* oh well */
|
|
}
|
|
offsets[SH_TOTAL_SIZE] += delta;
|
|
|
|
#if 0
|
|
if (!child_proc_info && wincap.needs_memory_protection ())
|
|
for (DWORD s = 0x950000; s <= 0xa40000; s += 0x1000)
|
|
VirtualAlloc ((void *) s, 4, MEM_RESERVE, PAGE_NOACCESS);
|
|
#endif
|
|
}
|
|
|
|
debug_printf ("name %s, shared %p (wanted %p), h %p", name, shared, addr, shared_h);
|
|
|
|
return shared;
|
|
}
|
|
|
|
void
|
|
shared_info::initialize (const char *user_name)
|
|
{
|
|
DWORD sversion = (DWORD) InterlockedExchange ((LONG *) &version, SHARED_VERSION_MAGIC);
|
|
if (!sversion)
|
|
{
|
|
/* Initialize the queue of deleted files. */
|
|
delqueue.init ();
|
|
|
|
/* Initialize tty table. */
|
|
tty.init ();
|
|
}
|
|
else
|
|
{
|
|
if (version != SHARED_VERSION_MAGIC)
|
|
{
|
|
multiple_cygwin_problem ("shared", version, SHARED_VERSION_MAGIC);
|
|
InterlockedExchange ((LONG *) &version, sversion);
|
|
}
|
|
while (!cb)
|
|
low_priority_sleep (0); // Should be hit only very very rarely
|
|
}
|
|
|
|
/* Initialize the Cygwin heap, if necessary */
|
|
if (!cygheap)
|
|
{
|
|
cygheap_init ();
|
|
cygheap->user.set_name (user_name);
|
|
}
|
|
|
|
heap_init ();
|
|
|
|
if (!sversion)
|
|
cb = sizeof (*this); // Do last, after all shared memory initializion
|
|
|
|
if (cb != SHARED_INFO_CB)
|
|
system_printf ("size of shared memory region changed from %u to %u",
|
|
SHARED_INFO_CB, cb);
|
|
}
|
|
|
|
void __stdcall
|
|
memory_init ()
|
|
{
|
|
getpagesize ();
|
|
|
|
char user_name[UNLEN + 1];
|
|
DWORD user_name_len = UNLEN + 1;
|
|
|
|
if (!GetUserName (user_name, &user_name_len))
|
|
strcpy (user_name, "unknown");
|
|
|
|
/* Initialize general shared memory */
|
|
HANDLE shared_h = cygheap ? cygheap->shared_h : NULL;
|
|
cygwin_shared = (shared_info *) open_shared ("shared",
|
|
CYGWIN_VERSION_SHARED_DATA,
|
|
shared_h,
|
|
sizeof (*cygwin_shared),
|
|
SH_CYGWIN_SHARED);
|
|
|
|
cygwin_shared->initialize (user_name);
|
|
|
|
cygheap->shared_h = shared_h;
|
|
ProtectHandleINH (cygheap->shared_h);
|
|
|
|
/* Allocate memory for the per-user mount table */
|
|
mount_table = (mount_info *) open_shared (user_name, MOUNT_VERSION,
|
|
cygwin_mount_h, sizeof (mount_info),
|
|
SH_MOUNT_TABLE);
|
|
debug_printf ("opening mount table for '%s' at %p", cygheap->user.name (),
|
|
mount_table);
|
|
ProtectHandleINH (cygwin_mount_h);
|
|
debug_printf ("mount table version %x at %p", mount_table->version, mount_table);
|
|
|
|
/* Initialize the Cygwin per-user mount table, if necessary */
|
|
if (!mount_table->version)
|
|
{
|
|
mount_table->version = MOUNT_VERSION_MAGIC;
|
|
debug_printf ("initializing mount table");
|
|
mount_table->cb = sizeof (*mount_table);
|
|
if (mount_table->cb != MOUNT_INFO_CB)
|
|
system_printf ("size of mount table region changed from %u to %u",
|
|
MOUNT_INFO_CB, mount_table->cb);
|
|
mount_table->init (); /* Initialize the mount table. */
|
|
}
|
|
else if (mount_table->version != MOUNT_VERSION_MAGIC)
|
|
multiple_cygwin_problem ("mount", mount_table->version, MOUNT_VERSION);
|
|
else if (mount_table->cb != MOUNT_INFO_CB)
|
|
multiple_cygwin_problem ("mount table size", mount_table->cb, MOUNT_INFO_CB);
|
|
|
|
}
|
|
|
|
unsigned
|
|
shared_info::heap_chunk_size ()
|
|
{
|
|
if (!heap_chunk)
|
|
{
|
|
/* Fetch misc. registry entries. */
|
|
|
|
reg_key reg (KEY_READ, NULL);
|
|
|
|
/* Note that reserving a huge amount of heap space does not result in
|
|
the use of swap since we are not committing it. */
|
|
/* FIXME: We should not be restricted to a fixed size heap no matter
|
|
what the fixed size is. */
|
|
|
|
heap_chunk = reg.get_int ("heap_chunk_in_mb", 0);
|
|
if (!heap_chunk) {
|
|
reg_key r1 (HKEY_LOCAL_MACHINE, KEY_READ, "SOFTWARE",
|
|
CYGWIN_INFO_CYGNUS_REGISTRY_NAME,
|
|
CYGWIN_INFO_CYGWIN_REGISTRY_NAME, NULL);
|
|
heap_chunk = r1.get_int ("heap_chunk_in_mb", 384);
|
|
}
|
|
|
|
if (heap_chunk < 4)
|
|
heap_chunk = 4 * 1024 * 1024;
|
|
else
|
|
heap_chunk <<= 20;
|
|
if (!heap_chunk)
|
|
heap_chunk = 384 * 1024 * 1024;
|
|
debug_printf ("fixed heap size is %u", heap_chunk);
|
|
}
|
|
|
|
return heap_chunk;
|
|
}
|