functionality. * cygheap.cc (init_cheap): Move cygheap_max calculation to _csbrk. (_csbrk): Reorganize to not assume first allocation is <= 1 page. (cygheap_setup_for_child): Mark protected handle as inheritable. * cygheap.h (cygheap_debug): New struct. (init_cygheap): Add new structure when debugging. * dcrt0.cc (dll_crt0_1): Remove call to debug_init. Close ppid_handle here, if appropriate. Don't protect subproc_ready, since it is already protected in the parent. Call memory_init prior to ProtectHandle to ensure that cygheap is set up. Call debug_fixup_after_fork_exec when appropriate. (_dll_crt0): Don't close ppid_handle here. * debug.cc: Use cygheap debug structure rather than static elements throughout. (add_handle): Don't issue a warning if attempt to protect handle in exactly the same way from exactly the same place. Add pid info to warning output. Accept additional argument controlling whether handle is to be inherited. Add pid to stored information. (debug_fixup_after_fork_exec): Renamed from debug_fixup_after_fork. Reorganize to avoid erroneously skipping handles. (mark_closed): Add pid info to warning output. (setclexec): Rename from setclexec_pid. * fhandler.cc (fhandler_base::get_default_fmode): Minor reorg. (fhandler_base::fstat): Add debugging output. (fhandler_base::set_inheritance): Call setclexec rather than setclexec_pid. (fhandler_base::fork_fixup): Ditto. * fhandler_console.cc (get_tty_stuff): Mark protected handle as inheritable. * fhandler_tty.cc (fhandler_tty_slave::open): Ditto. * tty.cc (tty::make_pipes): Ditto. (tty::common_init): Ditto. * fork.cc (fork_parent): Ditto. (fork_child): Close protected handles with correct name. Remove debug_fixup_after_fork call. * fhandler_socket.cc (fhandler_socket::create_secret_event): Mark protected handle as inheritable/non-inheritable, as appropriate. * shared.cc (memory_init): Mark protected handle as inheritable. Call debug_init here. * sigproc.cc (wait_sig): Close protected handle with correct name. * spawn.cc (spawn_guts): Rename spr to subproc_ready and mark it as inheritable. * exceptions.cc (debugger_command): Try to run dumper.exe, if found. * syscalls.cc (fstat64): Don't follow symlinks for path_conv lookup since path is already resolved.
211 lines
5.5 KiB
C++
211 lines
5.5 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 <errno.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"
|
|
|
|
shared_info NO_COPY *cygwin_shared = NULL;
|
|
mount_info NO_COPY *mount_table = NULL;
|
|
HANDLE cygwin_mount_h;
|
|
|
|
char * __stdcall
|
|
shared_name (const char *str, int num)
|
|
{
|
|
static NO_COPY char buf[MAX_PATH] = {0};
|
|
extern bool _cygwin_testing;
|
|
|
|
__small_sprintf (buf, "%s.%s.%d", cygwin_version.shared_id, str, num);
|
|
if (!_cygwin_testing)
|
|
strcat (buf, cygwin_version.dll_build_date);
|
|
return buf;
|
|
}
|
|
|
|
void * __stdcall
|
|
open_shared (const char *name, int n, HANDLE &shared_h, DWORD size, void *addr)
|
|
{
|
|
void *shared;
|
|
|
|
if (!shared_h)
|
|
{
|
|
char *mapname;
|
|
if (!name)
|
|
mapname = NULL;
|
|
else
|
|
{
|
|
mapname = shared_name (name, n);
|
|
shared_h = OpenFileMappingA (FILE_MAP_READ | FILE_MAP_WRITE,
|
|
TRUE, mapname);
|
|
}
|
|
if (!shared_h &&
|
|
!(shared_h = CreateFileMappingA (INVALID_HANDLE_VALUE,
|
|
&sec_all,
|
|
PAGE_READWRITE,
|
|
0,
|
|
size,
|
|
mapname)))
|
|
api_fatal ("CreateFileMappingA, %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);
|
|
}
|
|
|
|
if (!shared)
|
|
api_fatal ("MapViewOfFileEx '%s'(%p), %E. Terminating.", name, shared_h);
|
|
|
|
debug_printf ("name %s, shared %p (wanted %p), h %p", name, shared, addr, shared_h);
|
|
|
|
/* FIXME: I couldn't find anywhere in the documentation a note about
|
|
whether the memory is initialized to zero. The code assumes it does
|
|
and since this part seems to be working, we'll leave it as is. */
|
|
return shared;
|
|
}
|
|
|
|
void
|
|
shared_info::initialize ()
|
|
{
|
|
if (version)
|
|
{
|
|
if (version != SHARED_VERSION_MAGIC)
|
|
multiple_cygwin_problem ("shared", version, SHARED_VERSION);
|
|
else if (cb != SHARED_INFO_CB)
|
|
multiple_cygwin_problem ("shared size", cb, SHARED_INFO_CB);
|
|
return;
|
|
}
|
|
|
|
/* Initialize the queue of deleted files. */
|
|
delqueue.init ();
|
|
|
|
/* Initialize tty table. */
|
|
tty.init ();
|
|
version = SHARED_VERSION_MAGIC;
|
|
cb = sizeof (*this);
|
|
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 ()
|
|
{
|
|
/* 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),
|
|
cygwin_shared_address);
|
|
|
|
cygwin_shared->initialize ();
|
|
|
|
/* Allocate memory for the per-user mount table */
|
|
char user_name[UNLEN + 1];
|
|
DWORD user_name_len = UNLEN + 1;
|
|
|
|
if (!GetUserName (user_name, &user_name_len))
|
|
strcpy (user_name, "unknown");
|
|
|
|
/* Initialize the Cygwin heap, if necessary */
|
|
if (!cygheap)
|
|
{
|
|
cygheap_init ();
|
|
cygheap->user.set_name (user_name);
|
|
}
|
|
|
|
debug_init ();
|
|
|
|
cygheap->shared_h = shared_h;
|
|
ProtectHandleINH (cygheap->shared_h);
|
|
|
|
heap_init ();
|
|
mount_table = (mount_info *) open_shared (user_name, MOUNT_VERSION,
|
|
cygwin_mount_h,
|
|
sizeof (mount_info), 0);
|
|
debug_printf ("opening mount table for '%s' at %p", cygheap->user.name (),
|
|
mount_table_address);
|
|
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);
|
|
|
|
}
|
|
|
|
void __stdcall
|
|
shared_terminate ()
|
|
{
|
|
if (cygheap->shared_h)
|
|
ForceCloseHandle (cygheap->shared_h);
|
|
if (cygwin_mount_h)
|
|
ForceCloseHandle (cygwin_mount_h);
|
|
}
|
|
|
|
unsigned
|
|
shared_info::heap_chunk_size ()
|
|
{
|
|
if (!heap_chunk_in_mb)
|
|
{
|
|
/* 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_in_mb = reg.get_int ("heap_chunk_in_mb", 256);
|
|
if (heap_chunk_in_mb < 4)
|
|
{
|
|
heap_chunk_in_mb = 4;
|
|
reg.set_int ("heap_chunk_in_mb", heap_chunk_in_mb);
|
|
}
|
|
}
|
|
|
|
return heap_chunk_in_mb << 20;
|
|
}
|