void neko_gc_init() {
GC_set_warn_proc((GC_warn_proc)(void*)null_warn_proc);
# ifndef NEKO_WINDOWS
// we can't set this on windows with old GC since
// it's already initialized through its own DllMain
GC_all_interior_pointers = 0;
# endif
#if (GC_VERSION_MAJOR >= 7) && defined(NEKO_WINDOWS)
GC_all_interior_pointers = 0;
# ifndef NEKO_STANDALONE
GC_use_DllMain(); // needed to auto-detect threads created by Apache
# endif
#endif
GC_java_finalization = 1;
GC_init();
GC_no_dls = 1;
#ifdef LOW_MEM
GC_dont_expand = 1;
#endif
GC_clear_roots();
#if defined(GC_LOG) && defined(NEKO_POSIX)
{
struct sigaction act;
act.sa_sigaction = NULL;
act.sa_handler = handle_signal;
act.sa_flags = 0;
sigemptyset(&act.sa_mask);
sigaction(SIGSEGV,&act,NULL);
}
#endif
}
void boehm_gc_startup_code(void)
{
GC_init();
GC_finalizer_notifier = &boehm_gc_finalizer_notifier;
GC_finalize_on_demand = 1;
GC_set_warn_proc(mem_boehm_ignore);
}
jboolean initGC(Options* options) {
GC_set_no_dls(1);
GC_set_java_finalization(1);
GC_INIT();
if (options->maxHeapSize > 0) {
GC_set_max_heap_size(options->maxHeapSize);
}
if (options->initialHeapSize > 0) {
size_t now = GC_get_heap_size();
if (options->initialHeapSize > now) {
GC_expand_hp(options->initialHeapSize - now);
}
}
objectGCKind = GC_new_kind(GC_new_free_list(), GC_MAKE_PROC(GC_new_proc(markObject), 0), 0, 1);
largeArrayGCKind = GC_new_kind(GC_new_free_list(), GC_DS_LENGTH, 1, 1);
atomicObjectGCKind = GC_new_kind(GC_new_free_list(), GC_DS_LENGTH, 0, 1);
referentEntryGCKind = gcNewDirectBitmapKind(REFERENT_ENTRY_GC_BITMAP);
if (rvmInitMutex(&referentsLock) != 0) {
return FALSE;
}
if (rvmInitMutex(&gcRootsLock) != 0) {
return FALSE;
}
GC_set_warn_proc(gcWarnProc);
return TRUE;
}
void
mono_gc_base_init (void)
{
MonoThreadInfoCallbacks cb;
char *env;
if (gc_initialized)
return;
/*
* Handle the case when we are called from a thread different from the main thread,
* confusing libgc.
* FIXME: Move this to libgc where it belongs.
*
* we used to do this only when running on valgrind,
* but it happens also in other setups.
*/
#if defined(HAVE_PTHREAD_GETATTR_NP) && defined(HAVE_PTHREAD_ATTR_GETSTACK)
{
size_t size;
void *sstart;
pthread_attr_t attr;
pthread_getattr_np (pthread_self (), &attr);
pthread_attr_getstack (&attr, &sstart, &size);
pthread_attr_destroy (&attr);
/*g_print ("stackbottom pth is: %p\n", (char*)sstart + size);*/
#ifdef __ia64__
/*
* The calculation above doesn't seem to work on ia64, also we need to set
* GC_register_stackbottom as well, but don't know how.
*/
#else
/* apparently with some linuxthreads implementations sstart can be NULL,
* fallback to the more imprecise method (bug# 78096).
*/
if (sstart) {
GC_stackbottom = (char*)sstart + size;
} else {
int dummy;
gsize stack_bottom = (gsize)&dummy;
stack_bottom += 4095;
stack_bottom &= ~4095;
GC_stackbottom = (char*)stack_bottom;
}
#endif
}
#elif defined(HAVE_PTHREAD_GET_STACKSIZE_NP) && defined(HAVE_PTHREAD_GET_STACKADDR_NP)
GC_stackbottom = (char*)pthread_get_stackaddr_np (pthread_self ());
#elif defined(__OpenBSD__)
# include <pthread_np.h>
{
stack_t ss;
int rslt;
rslt = pthread_stackseg_np(pthread_self(), &ss);
g_assert (rslt == 0);
GC_stackbottom = (char*)ss.ss_sp;
}
#elif defined(__native_client__)
/* Do nothing, GC_stackbottom is set correctly in libgc */
#else
{
int dummy;
gsize stack_bottom = (gsize)&dummy;
stack_bottom += 4095;
stack_bottom &= ~4095;
/*g_print ("stackbottom is: %p\n", (char*)stack_bottom);*/
GC_stackbottom = (char*)stack_bottom;
}
#endif
#if !defined(PLATFORM_ANDROID)
/* If GC_no_dls is set to true, GC_find_limit is not called. This causes a seg fault on Android. */
GC_no_dls = TRUE;
#endif
GC_init ();
GC_oom_fn = mono_gc_out_of_memory;
GC_set_warn_proc (mono_gc_warning);
GC_finalize_on_demand = 1;
GC_finalizer_notifier = mono_gc_finalize_notify;
#ifdef HAVE_GC_GCJ_MALLOC
GC_init_gcj_malloc (5, NULL);
#endif
#ifdef HAVE_GC_ALLOW_REGISTER_THREADS
GC_allow_register_threads();
#endif
if ((env = getenv ("MONO_GC_PARAMS"))) {
char **ptr, **opts = g_strsplit (env, ",", -1);
for (ptr = opts; *ptr; ++ptr) {
char *opt = *ptr;
if (g_str_has_prefix (opt, "max-heap-size=")) {
glong max_heap;
opt = strchr (opt, '=') + 1;
if (*opt && mono_gc_parse_environment_string_extract_number (opt, &max_heap)) {
if (max_heap < MIN_BOEHM_MAX_HEAP_SIZE) {
fprintf (stderr, "max-heap-size must be at least %dMb.\n", MIN_BOEHM_MAX_HEAP_SIZE_IN_MB);
exit (1);
}
GC_set_max_heap_size (max_heap);
} else {
fprintf (stderr, "max-heap-size must be an integer.\n");
exit (1);
}
continue;
} else {
fprintf (stderr, "MONO_GC_PARAMS must be a comma-delimited list of one or more of the following:\n");
fprintf (stderr, " max-heap-size=N (where N is an integer, possibly with a k, m or a g suffix)\n");
exit (1);
}
}
g_strfreev (opts);
}
memset (&cb, 0, sizeof (cb));
cb.thread_register = boehm_thread_register;
cb.mono_method_is_critical = (gpointer)mono_runtime_is_critical_method;
#ifndef HOST_WIN32
cb.mono_gc_pthread_create = (gpointer)mono_gc_pthread_create;
#endif
mono_threads_init (&cb, sizeof (MonoThreadInfo));
mono_gc_enable_events ();
gc_initialized = TRUE;
}
int main(int argc, char *argv[])
{
int run_as_daemon;
int debug;
pid_t pid = 0;
FILE *file_out;
struct sigaction sv;
#if WITH_MALLOC_BOEHM_GC
GC_find_leak = 1;
GC_set_warn_proc(gc_warn_proc);
GC_enable_incremental();
#endif
run_as_daemon = 1;
debug = 0;
tools_init();
/* set up some signal handlers */
memset(&sv, 0, sizeof(sv));
sigemptyset(&sv.sa_mask);
sv.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &sv, NULL);
sv.sa_handler = sigaction_rehash;
sigaction(SIGHUP, &sv, NULL);
sv.sa_handler = sigaction_writedb;
sigaction(SIGINT, &sv, NULL);
sv.sa_handler = sigaction_exit;
sigaction(SIGQUIT, &sv, NULL);
sv.sa_handler = sigaction_wait;
sigaction(SIGCHLD, &sv, NULL);
if (argc > 1) { /* parse command line, if any */
int c;
struct option options[] =
{
{"config", 1, 0, 'c'},
{"debug", 0, 0, 'd'},
{"foreground", 0, 0, 'f'},
{"help", 0, 0, 'h'},
{"check", 0, 0, 'k'},
{"replay", 1, 0, 'r'},
{"version", 0, 0, 'v'},
{0, 0, 0, 0}
};
while ((c = getopt_long(argc, argv, "c:dfhkr:v", options, NULL)) != -1) {
switch (c) {
case 'c':
services_config = optarg;
break;
case 'k':
if (conf_read(services_config)) {
printf("%s appears to be a valid configuration file.\n", services_config);
} else {
printf("%s is an invalid configuration file.\n", services_config);
}
exit(0);
case 'r':
replay_file = fopen(optarg, "r");
if (!replay_file) {
fprintf(stderr, "Could not open %s for reading: %s (%d)\n",
optarg, strerror(errno), errno);
exit(0);
}
break;
case 'd':
debug = 1;
break;
case 'f':
run_as_daemon = 0;
break;
case 'v':
version();
license();
exit(0);
case 'h':
default:
usage(argv[0]);
exit(0);
}
}
}
version();
if (replay_file) {
/* We read a line here to "prime" the replay file parser, but
* mostly to get the right value of "now" for when we do the
* irc_introduce. */
replay_read_line();
} else {
now = time(NULL);
}
boot_time = now;
fprintf(stdout, "Initializing daemon...\n");
if (!conf_read(services_config)) {
fprintf(stderr, "Unable to read %s.\n", services_config);
exit(1);
}
conf_register_reload(uplink_compile);
if (run_as_daemon) {
/* Attempt to fork into the background if daemon mode is on. */
pid = fork();
if (pid < 0) {
fprintf(stderr, "Unable to fork: %s\n", strerror(errno));
} else if (pid > 0) {
fprintf(stdout, "Forking into the background (pid: %d)...\n", pid);
exit(0);
}
setsid();
}
file_out = fopen(PID_FILE, "w");
if (file_out == NULL) {
/* Create the main process' pid file */
fprintf(stderr, "Unable to create PID file: %s", strerror(errno));
} else {
fprintf(file_out, "%i\n", (int)getpid());
fclose(file_out);
}
if (run_as_daemon) {
/* Close these since we should not use them from now on. */
fclose(stdin);
fclose(stdout);
fclose(stderr);
}
services_argc = argc;
services_argv = argv;
atexit(call_exit_funcs);
reg_exit_func(main_shutdown, NULL);
log_init();
MAIN_LOG = log_register_type("x3", "file:main.log");
if (debug)
log_debug();
ioset_init();
init_structs();
init_parse();
modcmd_init();
saxdb_init();
sar_init();
gline_init();
shun_init();
mail_init();
helpfile_init();
conf_globals(); /* initializes the core services */
conf_rlimits();
modules_init();
message_register_table(msgtab);
modcmd_finalize();
saxdb_finalize();
helpfile_finalize();
modules_finalize();
/* The first exit func to be called *should* be saxdb_write_all(). */
reg_exit_func(saxdb_write_all, NULL);
if (replay_file) {
char *msg;
log_module(MAIN_LOG, LOG_INFO, "Beginning replay...");
srand(now);
replay_event_loop();
if ((msg = dict_sanity_check(clients))) {
log_module(MAIN_LOG, LOG_ERROR, "Clients insanity: %s", msg);
free(msg);
}
if ((msg = dict_sanity_check(channels))) {
log_module(MAIN_LOG, LOG_ERROR, "Channels insanity: %s", msg);
free(msg);
}
if ((msg = dict_sanity_check(servers))) {
log_module(MAIN_LOG, LOG_ERROR, "Servers insanity: %s", msg);
free(msg);
}
} else {
now = time(NULL);
srand(now);
ioset_run();
}
return 0;
}
void
mono_gc_base_init (void)
{
if (gc_initialized)
return;
/*
* Handle the case when we are called from a thread different from the main thread,
* confusing libgc.
* FIXME: Move this to libgc where it belongs.
*
* we used to do this only when running on valgrind,
* but it happens also in other setups.
*/
#if defined(HAVE_PTHREAD_GETATTR_NP) && defined(HAVE_PTHREAD_ATTR_GETSTACK)
{
size_t size;
void *sstart;
pthread_attr_t attr;
pthread_getattr_np (pthread_self (), &attr);
pthread_attr_getstack (&attr, &sstart, &size);
pthread_attr_destroy (&attr);
/*g_print ("stackbottom pth is: %p\n", (char*)sstart + size);*/
#ifdef __ia64__
/*
* The calculation above doesn't seem to work on ia64, also we need to set
* GC_register_stackbottom as well, but don't know how.
*/
#else
/* apparently with some linuxthreads implementations sstart can be NULL,
* fallback to the more imprecise method (bug# 78096).
*/
if (sstart) {
GC_stackbottom = (char*)sstart + size;
} else {
int dummy;
gsize stack_bottom = (gsize)&dummy;
stack_bottom += 4095;
stack_bottom &= ~4095;
GC_stackbottom = (char*)stack_bottom;
}
#endif
}
#elif defined(HAVE_PTHREAD_GET_STACKSIZE_NP) && defined(HAVE_PTHREAD_GET_STACKADDR_NP)
GC_stackbottom = (char*)pthread_get_stackaddr_np (pthread_self ());
#elif defined(__OpenBSD__)
# include <pthread_np.h>
{
stack_t ss;
int rslt;
rslt = pthread_stackseg_np(pthread_self(), &ss);
g_assert (rslt == 0);
GC_stackbottom = (char*)ss.ss_sp;
}
#else
{
int dummy;
gsize stack_bottom = (gsize)&dummy;
stack_bottom += 4095;
stack_bottom &= ~4095;
/*g_print ("stackbottom is: %p\n", (char*)stack_bottom);*/
GC_stackbottom = (char*)stack_bottom;
}
#endif
#if !defined(PLATFORM_ANDROID)
/* If GC_no_dls is set to true, GC_find_limit is not called. This causes a seg fault on Android. */
GC_no_dls = TRUE;
#endif
GC_init ();
GC_oom_fn = mono_gc_out_of_memory;
GC_set_warn_proc (mono_gc_warning);
GC_finalize_on_demand = 1;
GC_finalizer_notifier = mono_gc_finalize_notify;
#ifdef HAVE_GC_GCJ_MALLOC
GC_init_gcj_malloc (5, NULL);
#endif
mono_gc_enable_events ();
gc_initialized = TRUE;
}