newlib/winsup/cygwin/shared.cc

494 lines
14 KiB
C++

/* shared.cc: shared data area support.
Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
2006, 2007, 2008, 2009, 2010, 2011 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 "miscfuncs.h"
#include <unistd.h>
#include "cygerrno.h"
#include "pinfo.h"
#include "path.h"
#include "fhandler.h"
#include "dtable.h"
#include "cygheap.h"
#include "heap.h"
#include "shared_info_magic.h"
#include "registry.h"
#include "cygwin_version.h"
#include "pwdgrp.h"
#include "spinlock.h"
#include <alloca.h>
#include <wchar.h>
#include <wingdi.h>
#include <winuser.h>
shared_info NO_COPY *cygwin_shared;
user_info NO_COPY *user_shared;
HANDLE NO_COPY cygwin_shared_h;
HANDLE NO_COPY cygwin_user_h;
WCHAR installation_root[PATH_MAX] __attribute__((section (".cygwin_dll_common"), shared));
UNICODE_STRING installation_key __attribute__((section (".cygwin_dll_common"), shared));
WCHAR installation_key_buf[18] __attribute__((section (".cygwin_dll_common"), shared));
static LONG installation_root_inited __attribute__((section (".cygwin_dll_common"), shared));
#define SPIN_WAIT 10000
/* Use absolute path of cygwin1.dll to derive the Win32 dir which
is our installation_root. Note that we can't handle Cygwin installation
root dirs of more than 4K path length. I assume that's ok...
This function also generates the installation_key value. It's a 64 bit
hash value based on the path of the Cygwin DLL itself. It's subsequently
used when generating shared object names. Thus, different Cygwin
installations generate different object names and so are isolated from
each other.
Having this information, the installation key together with the
installation root path is written to the registry. The idea is that
cygcheck can print the paths into which the Cygwin DLL has been
installed for debugging purposes.
Last but not least, the new cygwin properties datastrcuture is checked
for the "disabled_key" value, which is used to determine whether the
installation key is actually added to all object names or not. This is
used as a last resort for debugging purposes, usually. However, there
could be another good reason to re-enable object name collisions between
multiple Cygwin DLLs, which we're just not aware of right now. Cygcheck
can be used to change the value in an existing Cygwin DLL binary. */
void inline
init_installation_root ()
{
spinlock iri (installation_root_inited);
if (!iri)
{
if (!GetModuleFileNameW (cygwin_hmodule, installation_root, PATH_MAX))
api_fatal ("Can't initialize Cygwin installation root dir.\n"
"GetModuleFileNameW(%p, %p, %u), %E",
cygwin_hmodule, installation_root, PATH_MAX);
PWCHAR p = installation_root;
if (wcsncmp (p, L"\\\\?\\", 4)) /* No long path prefix. */
{
if (!wcsncasecmp (p, L"\\\\", 2)) /* UNC */
{
p = wcpcpy (p, L"\\??\\UN");
GetModuleFileNameW (cygwin_hmodule, p, PATH_MAX - 6);
*p = L'C';
}
else
{
p = wcpcpy (p, L"\\??\\");
GetModuleFileNameW (cygwin_hmodule, p, PATH_MAX - 4);
}
}
installation_root[1] = L'?';
RtlInitEmptyUnicodeString (&installation_key, installation_key_buf,
sizeof installation_key_buf);
RtlInt64ToHexUnicodeString (hash_path_name (0, installation_root),
&installation_key, FALSE);
PWCHAR w = wcsrchr (installation_root, L'\\');
if (w)
{
*w = L'\0';
w = wcsrchr (installation_root, L'\\');
}
if (!w)
api_fatal ("Can't initialize Cygwin installation root dir.\n"
"Invalid DLL path");
*w = L'\0';
for (int i = 1; i >= 0; --i)
{
reg_key r (i, KEY_WRITE, _WIDE (CYGWIN_INFO_INSTALLATIONS_NAME),
NULL);
if (NT_SUCCESS (r.set_string (installation_key_buf,
installation_root)))
break;
}
if (cygwin_props.disable_key)
{
installation_key.Length = 0;
installation_key.Buffer[0] = L'\0';
}
}
}
/* This function returns a handle to the top-level directory in the global
NT namespace used to implement global objects including shared memory. */
HANDLE
get_shared_parent_dir ()
{
static HANDLE dir;
UNICODE_STRING uname;
OBJECT_ATTRIBUTES attr;
NTSTATUS status;
if (!dir)
{
WCHAR bnoname[MAX_PATH];
__small_swprintf (bnoname, L"\\BaseNamedObjects\\%s%s-%S",
cygwin_version.shared_id,
_cygwin_testing ? cygwin_version.dll_build_date : "",
&installation_key);
RtlInitUnicodeString (&uname, bnoname);
InitializeObjectAttributes (&attr, &uname, OBJ_INHERIT | OBJ_OPENIF,
NULL, everyone_sd (CYG_SHARED_DIR_ACCESS));
status = NtCreateDirectoryObject (&dir, CYG_SHARED_DIR_ACCESS, &attr);
if (!NT_SUCCESS (status))
api_fatal ("NtCreateDirectoryObject(%S): %p", &uname, status);
}
return dir;
}
HANDLE
get_session_parent_dir ()
{
static HANDLE dir;
UNICODE_STRING uname;
OBJECT_ATTRIBUTES attr;
NTSTATUS status;
if (!dir)
{
PROCESS_SESSION_INFORMATION psi;
status = NtQueryInformationProcess (NtCurrentProcess (),
ProcessSessionInformation,
&psi, sizeof psi, NULL);
if (!NT_SUCCESS (status) || psi.SessionId == 0)
dir = get_shared_parent_dir ();
else
{
WCHAR bnoname[MAX_PATH];
__small_swprintf (bnoname,
L"\\Sessions\\BNOLINKS\\%d\\%s%s-%S",
psi.SessionId, cygwin_version.shared_id,
_cygwin_testing ? cygwin_version.dll_build_date : "",
&installation_key);
RtlInitUnicodeString (&uname, bnoname);
InitializeObjectAttributes (&attr, &uname, OBJ_INHERIT | OBJ_OPENIF,
NULL, everyone_sd(CYG_SHARED_DIR_ACCESS));
status = NtCreateDirectoryObject (&dir, CYG_SHARED_DIR_ACCESS, &attr);
if (!NT_SUCCESS (status))
api_fatal ("NtCreateDirectoryObject(%S): %p", &uname, status);
}
}
return dir;
}
char * __stdcall
shared_name (char *ret_buf, const char *str, int num)
{
__small_sprintf (ret_buf, "%s.%d", str, num);
return ret_buf;
}
WCHAR * __stdcall
shared_name (WCHAR *ret_buf, const WCHAR *str, int num)
{
__small_swprintf (ret_buf, L"%W.%d", str, num);
return ret_buf;
}
#define page_const (65535)
#define pround(n) (((size_t) (n) + page_const) & ~page_const)
static ptrdiff_t offsets[] =
{
- pround (sizeof (shared_info))
- pround (sizeof (user_info))
- pround (sizeof (console_state))
- pround (sizeof (_pinfo)),
- pround (sizeof (user_info))
- pround (sizeof (console_state))
- pround (sizeof (_pinfo)),
- pround (sizeof (console_state))
- pround (sizeof (_pinfo)),
- pround (sizeof (_pinfo)),
0
};
#define off_addr(x) ((void *)((caddr_t) cygwin_hmodule + offsets[x]))
void * __stdcall
open_shared (const WCHAR *name, int n, HANDLE& shared_h, DWORD size,
shared_locations m, PSECURITY_ATTRIBUTES psa, DWORD access)
{
return open_shared (name, n, shared_h, size, &m, psa, access);
}
void * __stdcall
open_shared (const WCHAR *name, int n, HANDLE& shared_h, DWORD size,
shared_locations *m, PSECURITY_ATTRIBUTES psa, DWORD access)
{
void *shared;
void *addr;
if (*m == SH_JUSTCREATE || *m == SH_JUSTOPEN)
addr = NULL;
else
{
addr = off_addr (*m);
VirtualFree (addr, 0, MEM_RELEASE);
}
WCHAR map_buf[MAX_PATH];
WCHAR *mapname = NULL;
if (shared_h)
*m = SH_JUSTOPEN;
else
{
if (name)
mapname = shared_name (map_buf, name, n);
if (*m == SH_JUSTOPEN)
shared_h = OpenFileMappingW (access, FALSE, mapname);
else
{
shared_h = CreateFileMappingW (INVALID_HANDLE_VALUE, psa,
PAGE_READWRITE, 0, size, mapname);
if (GetLastError () == ERROR_ALREADY_EXISTS)
*m = SH_JUSTOPEN;
}
if (shared_h)
/* ok! */;
else if (*m != SH_JUSTOPEN)
api_fatal ("CreateFileMapping %W, %E. Terminating.", mapname);
else
return NULL;
}
shared = (shared_info *)
MapViewOfFileEx (shared_h, access, 0, 0, 0, addr);
if (!shared && addr)
{
shared = (shared_info *) MapViewOfFileEx (shared_h,
FILE_MAP_READ|FILE_MAP_WRITE,
0, 0, 0, NULL);
#ifdef DEBUGGING
system_printf ("relocating shared object %W(%d) from %p to %p", name, n, addr, shared);
#endif
offsets[0] = 0;
}
if (!shared)
api_fatal ("MapViewOfFileEx '%W'(%p), %E. Terminating.", mapname, shared_h);
if (*m == SH_CYGWIN_SHARED && offsets[0])
{
ptrdiff_t delta = (caddr_t) shared - (caddr_t) off_addr (0);
offsets[0] = (caddr_t) shared - (caddr_t) cygwin_hmodule;
for (int i = SH_USER_SHARED + 1; i < SH_TOTAL_SIZE; i++)
{
unsigned size = offsets[i + 1] - offsets[i];
offsets[i] += delta;
if (!VirtualAlloc (off_addr (i), size, MEM_RESERVE, PAGE_NOACCESS))
continue; /* oh well */
}
offsets[SH_TOTAL_SIZE] += delta;
}
debug_printf ("name %W, n %d, shared %p (wanted %p), h %p", mapname, n, shared, addr, shared_h);
return shared;
}
/* Second half of user shared initialization: Initialize content. */
void
user_info::initialize ()
{
/* Wait for initialization of the Cygwin per-user shared, if necessary */
spinlock sversion (version, CURR_USER_MAGIC);
if (!sversion)
{
cb = sizeof (*user_shared);
cygpsid sid (cygheap->user.sid ());
struct passwd *pw = internal_getpwsid (sid);
/* Correct the user name with what's defined in /etc/passwd before
loading the user fstab file. */
if (pw)
cygheap->user.set_name (pw->pw_name);
mountinfo.init (); /* Initialize the mount table. */
}
else if (sversion != CURR_USER_MAGIC)
sversion.multiple_cygwin_problem ("user shared memory version", version,
sversion);
else if (user_shared->cb != sizeof (*user_shared))
sversion.multiple_cygwin_problem ("user shared memory size", cb,
sizeof (*user_shared));
}
/* First half of user shared initialization: Create shared mem region. */
void
user_info::create (bool reinit)
{
WCHAR name[UNLEN + 1] = L""; /* Large enough for SID */
if (reinit)
{
if (!UnmapViewOfFile (user_shared))
debug_printf("UnmapViewOfFile %E");
if (!ForceCloseHandle (cygwin_user_h))
debug_printf("CloseHandle %E");
cygwin_user_h = NULL;
}
if (!cygwin_user_h)
cygheap->user.get_windows_id (name);
user_shared = (user_info *) open_shared (name, USER_VERSION,
cygwin_user_h, sizeof (user_info),
SH_USER_SHARED, &sec_none);
debug_printf ("opening user shared for '%W' at %p", name, user_shared);
ProtectHandleINH (cygwin_user_h);
debug_printf ("user shared version %x", user_shared->version);
if (reinit)
user_shared->initialize ();
}
void __stdcall
shared_destroy ()
{
ForceCloseHandle (cygwin_shared_h);
UnmapViewOfFile (cygwin_shared);
ForceCloseHandle (cygwin_user_h);
UnmapViewOfFile (user_shared);
}
/* Initialize obcaseinsensitive. Default to case insensitive on pre-XP. */
void
shared_info::init_obcaseinsensitive ()
{
NTSTATUS status;
DWORD def_obcaseinsensitive = 1;
obcaseinsensitive = def_obcaseinsensitive;
RTL_QUERY_REGISTRY_TABLE tab[2] = {
{ NULL, RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_NOSTRING,
L"obcaseinsensitive", &obcaseinsensitive, REG_DWORD,
&def_obcaseinsensitive, sizeof (DWORD) },
{ NULL, 0, NULL, NULL, 0, NULL, 0 }
};
status = RtlQueryRegistryValues (RTL_REGISTRY_CONTROL,
L"Session Manager\\kernel",
tab, NULL, NULL);
}
void inline
shared_info::create ()
{
cygwin_shared = (shared_info *) open_shared (L"shared",
CYGWIN_VERSION_SHARED_DATA,
cygwin_shared_h,
sizeof (*cygwin_shared),
SH_CYGWIN_SHARED);
cygwin_shared->initialize ();
}
void
shared_info::initialize ()
{
spinlock sversion (version, CURR_SHARED_MAGIC);
if (!sversion)
{
cb = sizeof (*this);
get_session_parent_dir (); /* Create session dir if first process. */
init_obcaseinsensitive (); /* Initialize obcaseinsensitive */
tty.init (); /* Initialize tty table */
mt.initialize (); /* Initialize shared tape information */
/* Defer debug output printing the installation root and installation key
up to this point. Debug output except for system_printf requires
the global shared memory to exist. */
debug_printf ("Installation root: <%W> key: <%S>",
installation_root, &installation_key);
}
else if (sversion != (LONG) CURR_SHARED_MAGIC)
sversion.multiple_cygwin_problem ("system shared memory version",
sversion, CURR_SHARED_MAGIC);
else if (cb != sizeof (*this))
system_printf ("size of shared memory region changed from %u to %u",
sizeof (*this), cb);
heap_init ();
}
void
memory_init (bool init_cygheap)
{
getpagesize ();
/* Initialize the Cygwin heap, if necessary */
if (init_cygheap)
{
cygheap_init ();
cygheap->user.init ();
}
init_installation_root (); /* Initialize installation root dir */
shared_info::create (); /* Initialize global shared memory */
user_info::create (false); /* Initialize per-user shared memory */
}
unsigned
shared_info::heap_slop_size ()
{
if (!heap_slop_inited)
{
/* Fetch from registry, first user then local machine. */
for (int i = 0; i < 2; i++)
{
reg_key reg (i, KEY_READ, NULL);
if ((heap_slop = reg.get_dword (L"heap_slop_in_mb", 0)))
break;
heap_slop = wincap.heapslop ();
}
heap_slop <<= 20;
heap_slop_inited = true;
}
return heap_slop;
}
unsigned
shared_info::heap_chunk_size ()
{
if (!heap_chunk)
{
/* Fetch from registry, first user then local machine. */
for (int i = 0; i < 2; i++)
{
reg_key reg (i, 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. */
if ((heap_chunk = reg.get_dword (L"heap_chunk_in_mb", 0)))
break;
heap_chunk = 384; /* Default */
}
if (heap_chunk < 4)
heap_chunk = 4 * 1024 * 1024;
else
heap_chunk <<= 20;
if (!heap_chunk)
heap_chunk = 384 * 1024 * 1024;
}
return heap_chunk;
}