mirror of
git://sourceware.org/git/newlib-cygwin.git
synced 2025-01-15 11:00:04 +08:00
2d1d1eb1e4
compiler bug. * autoload.cc (TryEnterCriticalSection): Remove. * dcrt0.cc (dll_crt0_0): Delete inappropriate setting of _my_tls.stackptr to NULL since it has really bad consequences. Make 'si' an automatic variable. * cygtls.cc (_threadinfo::init_thread): Correct thinko which caused thread list to be allocated every time. * cygtls.h (CYGTLS_PADSIZE): Define as const int. * sync.h: Make multiple inclusion safe. (muto::next): Eliminate. (muto::exiting_thread): New variable. (muto::set_exiting_thread): New function. (new_muto): Change to use different section for mutos since c++ give inexplicable warning in some cases otherwise. (new_muto1): Ditto. * dcrt0.cc (do_exit): Call muto::set_exiting_thread here. * sync.cc (muto_start): Eliminate. (muto::acquire): Always give exiting thread a lock. Never give thread a lock if exiting. (muto::release): Ditto for releasing. * dtable.cc (dtable::init_lock): Unline function and define here. * dtable.h (lock_cs): Define as a muto since critical sections seem to work oddly on Windows Me. (lock): Accommodate switch to muto. (unlock): Ditto. * exceptions.cc (setup_handler): Don't worry about acquiring mutos since that hasn't mattered for a long time. (signal_exit): Ditto: muto stuff will be handled automatically on exit now. * Makefile.in (DLL_IMPORTS): Link advapi32 to ensure proper DLL initialization. * autoload.cc (RegCloseKey): Arbitrarily choose this function as a "seed" to pull the advapi32 link library in. So, comment out the autoloading. * cygtls.cc (_threadinfo::init_thread): Just clear CYGTLS_PADSIZE. (_threadinfo::remove): Add debugging. (_threadinfo::find_tls): Ditto. * cygtls.h (_threadinfo::padding): Make zero length (for now?). * dcrt0.cc (dll_crt0_0): Move more initialization here from dll_crt0_1. (dll_crt0_1): See above. * dtable.h (dtable::lock): Remove commented out critical section locking. * dtable.h (dtable::init_lock): Remove commented out critical section locking. * dtable.h (dtable::unlock): Remove commented out critical section locking. * exceptions.cc (interruptible): bool'ize. * init.cc (threadfunc_fe): Revert to storing threadfunc at stack bottom. (munge_threadfunc): Ditto. Avoid adding overhead to calibration_thread. (prime_threads): Don't initialize tls stuff. (dll_entry): Make minor change to initialization order. * tlsoffsets.h: Regenerate. * sigproc.cc (wait_sig): Add sanity check for end of process thread exit. * select.h: Make minor formatting change. * Makefile.in: Add still more -fomit-frame-pointer functions. * dtable.h (dtable::lock): New function. (dtable::unlock): New function. (dtable::init_lock): New function. * cygheap.h (HEAP_TLS): Declare new enum value. (init_cygheap::threadlist): Declare new array. (init_cygheap::sthreads): Declare new variable. (cygheap_fdmanip::~cygheap_fdmanip): Use new dtable lock/unlock functions. (cygheap_fdnew::cygheap_fdnew): Ditto. (cygheap_fdget::cygheap_fdget): Ditto. * dtable.cc (dtable_init): Initialize fdtab critical section. (dtable::fixup_after_fork): Ditto. (dtable::fixup_after_exec): Ditto. (dtable::dup2): Use lock/unlock calls to protect access to fdtab. (dtable::find_fifo): Ditto. (dtable::fixup_before_fork): Ditto. (dtable::fixup_before_exec): Ditto. (dtable::set_file_pointers_for_exec): Ditto. (dtable::vfork_child_dup): Ditto. (dtable::vfork_parent_restore): Ditto. * syscalls.cc (close_all_files): Ditto. * sync.h (muto::acquired): Declare new function. (new_muto1): Declare new macro used to specify name of muto storage. * sync.cc (muto::acquired): Define new function. * cygthread.cc (cygthread::stub): Remove signal chain removal call since it is handled during initialization now. * cygthread.cc (cygthread::simplestub): Remove signal chain removal call since it is handled during initialization now. * cygtls.cc (sentry): New class used for locking. Use throughout. (_threadinfo::reset_exception): Don't pop stack. (_threadinfo::find_tls): Move from exceptions.cc. (_threadinfo::init_thread): Initialize array of threads rather than linked list. Take second argument indicating thread function for this thread. (_threadinfo::remove): Search thread array rather than linked list. Use sentry to lock. Only unlock if we got the lock. (_threadinfo::find_tls): Ditto for first two. (handle_threadlist_exception): Handle exceptions when manipulating the thread list in case of premature thread termination. (_threadinfo::init_threadlist_exceptions): Ditto. * cygtls.h (TLS_STACK_SIZE): Decrease size. (_threadinfo::padding): Add element to avoid overwriting lower part of stack. (_threadinfo::remove): Add a "wait" argument to control how long we wait for a lock before removing. * exceptions.cc (init_exception_handler): Make global. Take argument to control exception handler being set. (ctrl_c_handler): Wait forever when removing self from signal chain. (_threadinfo::find_tls): Move to cygtls.cc. (sig_handle): Reorganize detection for thread-specific signals. * heap.cc (heap_init): Rework slightly. Make fatal error more verbose. Remove malloc initialization since it can't happen during dll attach. * init.cc (search_for): Move address to search for on stack here. (threadfunc_ix): Ditto for stack offset. Make shared so that stack walk potentially only has to be done once when cygwin processes are running. (threadfunc_fe): Use standard tls to store thread function (may change back later). (calibration_thread): New function. Potentially called to find threadfunc_ix. (munge_threadfunc): Search for "search_for" value on stack. Output warning when thread func not found on stack. Use standard tls to store thread function. (prime_threads): New function. Called to prime thread front end. (dll_entry): Call dll_crt0_0 here when DLL_PROCESS_ATTACH. Call prime_threads here. Try to remove thread from signal list here. * sigproc.cc (wait_sig): Initialize threadlist exception stuff here. * thread.cc (pthread::exit): Pass argument to signal list remove function. * thread.h: Remove obsolete *ResourceLock defines. * tlsoffsets.h: Regenerate. * winsup.h (spf): Define temporary debug macro to be deleted later. * dcrt0.cc (dll_crt0_0): New function, called during DLL initialization. Mainly consists of code pulled from dll_crt0_1. (dll_crt0_1): See above. (_dll_crt0): Wait for initial calibration thread to complete, if appropriate. Move some stuff to dll_crt0_0. (initialize_main_tls): Accommodate argument change to _thread_info::init_thread. * fork.cc (fork_child): Ditto. (sync_with_child): Fix debug message. * external.cc (cygwin_internal): Remove special considerations for uninitialized dll since initialization happens during dll attach now. * dlfcn.cc (dlopen): Remove obsolete *ResourceLock calls. (dlclose): Ditto. * cygheap.h (init_cygheap::close_ctty): Declare new function. * cygheap.cc (init_cygheap::close_ctty): Define new function. * syscalls.cc (close_all_files): Use close_ctty. (setsid): Ditto. * cygthread.cc (cygthread::stub): Remove exception initialization. * cygthread.cc (cygthread::stub): Remove exception initialization. (cygthread::simplestub): Ditto. * thread.cc (pthread::thread_init_wrapper): Ditto. * cygtls.cc (_last_thread): Make static. (_threadinfo::call2): Initialize exception handler here. (_threadinfo::find_tls): Move here. * exceptions.cc (_threadinfo::find_tls): Move. * dcrt0.cc (__api_fatal): Add prefix info to message here rather than including it in every call to function. * winsup.h (api_fatal): Accommodate above change. * debug.cc (add_handle): Don't do anything if cygheap not around. (mark_closed): Ditto. * dll_init.cc (dll_list::detach): Fix debug output. * fork.cc (sync_with_child): Ditto. (vfork): Improve debug output. * heap.cc (heap_init): Ditto. * exceptions.cc (try_to_debug): Clarify message when debugger attaches.
464 lines
12 KiB
C++
464 lines
12 KiB
C++
/* cygheap.cc: Cygwin heap manager.
|
|
|
|
Copyright 2000, 2001, 2002, 2003 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 <string.h>
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include "security.h"
|
|
#include "path.h"
|
|
#include "fhandler.h"
|
|
#include "dtable.h"
|
|
#include "cygerrno.h"
|
|
#include "cygheap.h"
|
|
#include "child_info.h"
|
|
#include "heap.h"
|
|
#include "sync.h"
|
|
#include "shared_info.h"
|
|
#include "sigproc.h"
|
|
|
|
init_cygheap NO_COPY *cygheap;
|
|
void NO_COPY *cygheap_max;
|
|
|
|
static NO_COPY muto *cygheap_protect;
|
|
|
|
struct cygheap_entry
|
|
{
|
|
int type;
|
|
struct cygheap_entry *next;
|
|
char data[0];
|
|
};
|
|
|
|
#define NBUCKETS (sizeof (cygheap->buckets) / sizeof (cygheap->buckets[0]))
|
|
#define N0 ((_cmalloc_entry *) NULL)
|
|
#define to_cmalloc(s) ((_cmalloc_entry *) (((char *) (s)) - (unsigned) (N0->data)))
|
|
|
|
#define CFMAP_OPTIONS (SEC_RESERVE | PAGE_READWRITE)
|
|
#define MVMAP_OPTIONS (FILE_MAP_WRITE)
|
|
|
|
extern "C" {
|
|
static void __stdcall _cfree (void *ptr) __attribute__((regparm(1)));
|
|
}
|
|
|
|
static void
|
|
init_cheap ()
|
|
{
|
|
cygheap = (init_cygheap *) VirtualAlloc ((void *) &_cygheap_start, CYGHEAPSIZE, MEM_RESERVE, PAGE_NOACCESS);
|
|
if (!cygheap)
|
|
{
|
|
MEMORY_BASIC_INFORMATION m;
|
|
if (!VirtualQuery ((LPCVOID) &_cygheap_start, &m, sizeof m))
|
|
system_printf ("couldn't get memory info, %E");
|
|
system_printf ("Couldn't reserve space for cygwin's heap, %E");
|
|
api_fatal ("AllocationBase %p, BaseAddress %p, RegionSize %p, State %p\n",
|
|
m.AllocationBase, m.BaseAddress, m.RegionSize, m.State);
|
|
}
|
|
cygheap_max = cygheap;
|
|
}
|
|
|
|
static void dup_now (void *, child_info *, unsigned) __attribute__ ((regparm(3)));
|
|
static void
|
|
dup_now (void *newcygheap, child_info *ci, unsigned n)
|
|
{
|
|
if (!VirtualAlloc (newcygheap, n, MEM_COMMIT, PAGE_READWRITE))
|
|
api_fatal ("couldn't allocate new cygwin heap %p, %d for child, %E",
|
|
newcygheap, n);
|
|
memcpy (newcygheap, cygheap, n);
|
|
}
|
|
|
|
void *__stdcall
|
|
cygheap_setup_for_child (child_info *ci, bool dup_later)
|
|
{
|
|
void *newcygheap;
|
|
cygheap_protect->acquire ();
|
|
unsigned n = (char *) cygheap_max - (char *) cygheap;
|
|
unsigned size = CYGHEAPSIZE;
|
|
if (size < n)
|
|
size = n + (128 * 1024);
|
|
ci->cygheap_h = CreateFileMapping (INVALID_HANDLE_VALUE, &sec_none,
|
|
CFMAP_OPTIONS, 0, size, NULL);
|
|
if (!ci->cygheap_h)
|
|
api_fatal ("Couldn't create heap for child, size %d, %E", CYGHEAPSIZE);
|
|
newcygheap = MapViewOfFileEx (ci->cygheap_h, MVMAP_OPTIONS, 0, 0, 0, NULL);
|
|
ProtectHandle1INH (ci->cygheap_h, passed_cygheap_h);
|
|
if (!dup_later)
|
|
dup_now (newcygheap, ci, n);
|
|
cygheap_protect->release ();
|
|
ci->cygheap = cygheap;
|
|
ci->cygheap_max = cygheap_max;
|
|
return newcygheap;
|
|
}
|
|
|
|
void __stdcall
|
|
cygheap_setup_for_child_cleanup (void *newcygheap, child_info *ci,
|
|
bool dup_it_now)
|
|
{
|
|
if (dup_it_now)
|
|
{
|
|
/* NOTE: There is an assumption here that cygheap_max has not changed
|
|
between the time that cygheap_setup_for_child was called and now.
|
|
Make sure that this is a correct assumption. */
|
|
cygheap_protect->acquire ();
|
|
dup_now (newcygheap, ci, (char *) cygheap_max - (char *) cygheap);
|
|
cygheap_protect->release ();
|
|
}
|
|
UnmapViewOfFile (newcygheap);
|
|
ForceCloseHandle1 (ci->cygheap_h, passed_cygheap_h);
|
|
}
|
|
|
|
/* Called by fork or spawn to reallocate cygwin heap */
|
|
void __stdcall
|
|
cygheap_fixup_in_child (bool execed)
|
|
{
|
|
cygheap = child_proc_info->cygheap;
|
|
cygheap_max = child_proc_info->cygheap_max;
|
|
void *addr = !wincap.map_view_of_file_ex_sucks () ? cygheap : NULL;
|
|
void *newaddr;
|
|
|
|
newaddr = MapViewOfFileEx (child_proc_info->cygheap_h, MVMAP_OPTIONS, 0, 0, 0, addr);
|
|
if (newaddr != cygheap)
|
|
{
|
|
if (!newaddr)
|
|
newaddr = MapViewOfFileEx (child_proc_info->cygheap_h, MVMAP_OPTIONS, 0, 0, 0, NULL);
|
|
DWORD n = (DWORD) cygheap_max - (DWORD) cygheap;
|
|
/* Reserve cygwin heap in same spot as parent */
|
|
if (!VirtualAlloc (cygheap, CYGHEAPSIZE, MEM_RESERVE, PAGE_NOACCESS))
|
|
{
|
|
MEMORY_BASIC_INFORMATION m;
|
|
memset (&m, 0, sizeof m);
|
|
if (!VirtualQuery ((LPCVOID) cygheap, &m, sizeof m))
|
|
system_printf ("couldn't get memory info, %E");
|
|
|
|
system_printf ("Couldn't reserve space for cygwin's heap (%p <%p>) in child, %E", cygheap, newaddr);
|
|
api_fatal ("m.AllocationBase %p, m.BaseAddress %p, m.RegionSize %p, m.State %p\n",
|
|
m.AllocationBase, m.BaseAddress, m.RegionSize, m.State);
|
|
}
|
|
|
|
/* Allocate same amount of memory as parent */
|
|
if (!VirtualAlloc (cygheap, n, MEM_COMMIT, PAGE_READWRITE))
|
|
api_fatal ("Couldn't allocate space for child's heap %p, size %d, %E",
|
|
cygheap, n);
|
|
memcpy (cygheap, newaddr, n);
|
|
UnmapViewOfFile (newaddr);
|
|
}
|
|
|
|
ForceCloseHandle1 (child_proc_info->cygheap_h, passed_cygheap_h);
|
|
|
|
cygheap_init ();
|
|
debug_fixup_after_fork_exec ();
|
|
|
|
if (execed)
|
|
{
|
|
cygheap->user_heap.base = NULL; /* We can allocate the heap anywhere */
|
|
/* Walk the allocated memory chain looking for orphaned memory from
|
|
previous execs */
|
|
for (_cmalloc_entry *rvc = cygheap->chain; rvc; rvc = rvc->prev)
|
|
{
|
|
cygheap_entry *ce = (cygheap_entry *) rvc->data;
|
|
if (!rvc->ptr || rvc->b >= NBUCKETS || ce->type <= HEAP_1_START)
|
|
continue;
|
|
else if (ce->type < HEAP_1_MAX)
|
|
ce->type += HEAP_1_MAX; /* Mark for freeing after next exec */
|
|
else
|
|
_cfree (ce); /* Marked by parent for freeing in child */
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
init_cygheap::close_ctty ()
|
|
{
|
|
debug_printf ("closing cygheap->ctty %p", cygheap->ctty);
|
|
cygheap->ctty->close ();
|
|
if (cygheap->ctty_on_hold == cygheap->ctty)
|
|
cygheap->ctty_on_hold = NULL;
|
|
cygheap->ctty = NULL;
|
|
}
|
|
|
|
#define pagetrunc(x) ((void *) (((DWORD) (x)) & ~(4096 - 1)))
|
|
|
|
static void *__stdcall
|
|
_csbrk (int sbs)
|
|
{
|
|
void *prebrk = cygheap_max;
|
|
void *prebrka = pagetrunc (prebrk);
|
|
cygheap_max = (char *) cygheap_max + sbs;
|
|
if (!sbs || (prebrk != prebrka && prebrka == pagetrunc (cygheap_max)))
|
|
/* nothing to do */;
|
|
else if (!VirtualAlloc (prebrk, (DWORD) sbs, MEM_COMMIT, PAGE_READWRITE))
|
|
{
|
|
malloc_printf ("couldn't commit memory for cygwin heap, %E");
|
|
__seterrno ();
|
|
cygheap_max = (char *) cygheap_max - sbs;
|
|
return NULL;
|
|
}
|
|
|
|
return prebrk;
|
|
}
|
|
|
|
extern "C" void __stdcall
|
|
cygheap_init ()
|
|
{
|
|
new_muto (cygheap_protect);
|
|
if (!cygheap)
|
|
{
|
|
init_cheap ();
|
|
(void) _csbrk (sizeof (*cygheap));
|
|
}
|
|
if (!cygheap->fdtab)
|
|
cygheap->fdtab.init ();
|
|
if (!cygheap->sigs)
|
|
sigalloc ();
|
|
|
|
if (!cygheap->shared_prefix)
|
|
cygheap->shared_prefix = cstrdup (
|
|
wincap.has_terminal_services ()
|
|
&& (set_process_privilege (SE_CREATE_GLOBAL_NAME, true) >= 0
|
|
|| GetLastError () == ERROR_NO_SUCH_PRIVILEGE)
|
|
? "Global\\" : "");
|
|
}
|
|
|
|
/* Copyright (C) 1997, 2000 DJ Delorie */
|
|
|
|
static void *_cmalloc (unsigned size) __attribute ((regparm(1)));
|
|
static void *__stdcall _crealloc (void *ptr, unsigned size) __attribute ((regparm(2)));
|
|
|
|
static void *__stdcall
|
|
_cmalloc (unsigned size)
|
|
{
|
|
_cmalloc_entry *rvc;
|
|
unsigned b, sz;
|
|
|
|
/* Calculate "bit bucket" and size as a power of two. */
|
|
for (b = 3, sz = 8; sz && sz < size; b++, sz <<= 1)
|
|
continue;
|
|
|
|
cygheap_protect->acquire ();
|
|
if (cygheap->buckets[b])
|
|
{
|
|
rvc = (_cmalloc_entry *) cygheap->buckets[b];
|
|
cygheap->buckets[b] = rvc->ptr;
|
|
rvc->b = b;
|
|
}
|
|
else
|
|
{
|
|
rvc = (_cmalloc_entry *) _csbrk (sz + sizeof (_cmalloc_entry));
|
|
if (!rvc)
|
|
{
|
|
cygheap_protect->release ();
|
|
return NULL;
|
|
}
|
|
|
|
rvc->b = b;
|
|
rvc->prev = cygheap->chain;
|
|
cygheap->chain = rvc;
|
|
}
|
|
cygheap_protect->release ();
|
|
return rvc->data;
|
|
}
|
|
|
|
static void __stdcall
|
|
_cfree (void *ptr)
|
|
{
|
|
cygheap_protect->acquire ();
|
|
_cmalloc_entry *rvc = to_cmalloc (ptr);
|
|
DWORD b = rvc->b;
|
|
rvc->ptr = cygheap->buckets[b];
|
|
cygheap->buckets[b] = (char *) rvc;
|
|
cygheap_protect->release ();
|
|
}
|
|
|
|
static void *__stdcall
|
|
_crealloc (void *ptr, unsigned size)
|
|
{
|
|
void *newptr;
|
|
if (ptr == NULL)
|
|
newptr = _cmalloc (size);
|
|
else
|
|
{
|
|
unsigned oldsize = 1 << to_cmalloc (ptr)->b;
|
|
if (size <= oldsize)
|
|
return ptr;
|
|
newptr = _cmalloc (size);
|
|
memcpy (newptr, ptr, oldsize);
|
|
_cfree (ptr);
|
|
}
|
|
return newptr;
|
|
}
|
|
|
|
/* End Copyright (C) 1997 DJ Delorie */
|
|
|
|
#define sizeof_cygheap(n) ((n) + sizeof (cygheap_entry))
|
|
|
|
#define N ((cygheap_entry *) NULL)
|
|
#define tocygheap(s) ((cygheap_entry *) (((char *) (s)) - (int) (N->data)))
|
|
|
|
inline static void *
|
|
creturn (cygheap_types x, cygheap_entry * c, unsigned len)
|
|
{
|
|
if (!c)
|
|
{
|
|
set_errno (ENOMEM);
|
|
return NULL;
|
|
}
|
|
c->type = x;
|
|
char *cend = ((char *) c + sizeof (*c) + len);
|
|
if (cygheap_max < cend)
|
|
cygheap_max = cend;
|
|
MALLOC_CHECK;
|
|
return (void *) c->data;
|
|
}
|
|
|
|
extern "C" void *__stdcall
|
|
cmalloc (cygheap_types x, DWORD n)
|
|
{
|
|
cygheap_entry *c;
|
|
MALLOC_CHECK;
|
|
c = (cygheap_entry *) _cmalloc (sizeof_cygheap (n));
|
|
if (!c)
|
|
system_printf ("cmalloc returned NULL");
|
|
return creturn (x, c, n);
|
|
}
|
|
|
|
extern "C" void *__stdcall
|
|
crealloc (void *s, DWORD n)
|
|
{
|
|
MALLOC_CHECK;
|
|
if (s == NULL)
|
|
return cmalloc (HEAP_STR, n); // kludge
|
|
|
|
assert (!inheap (s));
|
|
cygheap_entry *c = tocygheap (s);
|
|
cygheap_types t = (cygheap_types) c->type;
|
|
c = (cygheap_entry *) _crealloc (c, sizeof_cygheap (n));
|
|
if (!c)
|
|
system_printf ("crealloc returned NULL");
|
|
return creturn (t, c, n);
|
|
}
|
|
|
|
extern "C" void __stdcall
|
|
cfree (void *s)
|
|
{
|
|
assert (!inheap (s));
|
|
(void) _cfree (tocygheap (s));
|
|
MALLOC_CHECK;
|
|
}
|
|
|
|
extern "C" void __stdcall
|
|
cfree_and_set (char *&s, char *what)
|
|
{
|
|
if (s && s != almost_null)
|
|
cfree (s);
|
|
s = what;
|
|
}
|
|
|
|
extern "C" void *__stdcall
|
|
ccalloc (cygheap_types x, DWORD n, DWORD size)
|
|
{
|
|
cygheap_entry *c;
|
|
MALLOC_CHECK;
|
|
n *= size;
|
|
c = (cygheap_entry *) _cmalloc (sizeof_cygheap (n));
|
|
if (c)
|
|
memset (c->data, 0, n);
|
|
#ifdef DEBUGGING
|
|
if (!c)
|
|
system_printf ("ccalloc returned NULL");
|
|
#endif
|
|
return creturn (x, c, n);
|
|
}
|
|
|
|
extern "C" char *__stdcall
|
|
cstrdup (const char *s)
|
|
{
|
|
MALLOC_CHECK;
|
|
char *p = (char *) cmalloc (HEAP_STR, strlen (s) + 1);
|
|
if (!p)
|
|
return NULL;
|
|
strcpy (p, s);
|
|
MALLOC_CHECK;
|
|
return p;
|
|
}
|
|
|
|
extern "C" char *__stdcall
|
|
cstrdup1 (const char *s)
|
|
{
|
|
MALLOC_CHECK;
|
|
char *p = (char *) cmalloc (HEAP_1_STR, strlen (s) + 1);
|
|
if (!p)
|
|
return NULL;
|
|
strcpy (p, s);
|
|
MALLOC_CHECK;
|
|
return p;
|
|
}
|
|
|
|
void
|
|
cygheap_root::set (const char *posix, const char *native)
|
|
{
|
|
if (*posix == '/' && posix[1] == '\0')
|
|
{
|
|
if (m)
|
|
{
|
|
cfree (m);
|
|
m = NULL;
|
|
}
|
|
return;
|
|
}
|
|
if (!m)
|
|
m = (struct cygheap_root_mount_info *) ccalloc (HEAP_MOUNT, 1, sizeof (*m));
|
|
strcpy (m->posix_path, posix);
|
|
m->posix_pathlen = strlen (posix);
|
|
if (m->posix_pathlen >= 1 && m->posix_path[m->posix_pathlen - 1] == '/')
|
|
m->posix_path[--m->posix_pathlen] = '\0';
|
|
|
|
strcpy (m->native_path, native);
|
|
m->native_pathlen = strlen (native);
|
|
if (m->native_pathlen >= 1 && m->native_path[m->native_pathlen - 1] == '\\')
|
|
m->native_path[--m->native_pathlen] = '\0';
|
|
}
|
|
|
|
cygheap_user::~cygheap_user ()
|
|
{
|
|
#if 0
|
|
if (pname)
|
|
cfree (pname);
|
|
if (plogsrv)
|
|
cfree (plogsrv - 2);
|
|
if (pdomain)
|
|
cfree (pdomain);
|
|
if (psid)
|
|
cfree (psid);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
cygheap_user::set_name (const char *new_name)
|
|
{
|
|
bool allocated = !!pname;
|
|
|
|
if (allocated)
|
|
{
|
|
if (strcasematch (new_name, pname))
|
|
return;
|
|
cfree (pname);
|
|
}
|
|
|
|
pname = cstrdup (new_name ? new_name : "");
|
|
if (!allocated)
|
|
return; /* Initializing. Don't bother with other stuff. */
|
|
|
|
cfree_and_set (homedrive);
|
|
cfree_and_set (homepath);
|
|
cfree_and_set (plogsrv);
|
|
cfree_and_set (pdomain);
|
|
cfree_and_set (pwinname);
|
|
}
|
|
|