pid_t make_daemon(void) { pid_t pid; const char * devnull = "/dev/null"; pid = fork(); if (pid < 0) { cl_log(LOG_ERR, "%s: could not start daemon\n", cmdname); cl_perror("fork"); exit(1); }else if (pid > 0) { return pid; } cl_log_enable_stderr(FALSE); /* This is the child; ensure privileges have not been lost. */ maximize_priority(); sysrq_init(); umask(022); close(0); (void)open(devnull, O_RDONLY); close(1); (void)open(devnull, O_WRONLY); close(2); (void)open(devnull, O_WRONLY); cl_cdtocoredir(); return 0; }
gboolean crm_log_init( const char *entity, int level, gboolean coredir, gboolean to_stderr, int argc, char **argv) { /* const char *test = "Testing log daemon connection"; */ /* Redirect messages from glib functions to our handler */ /* cl_malloc_forced_for_glib(); */ g_log_set_handler(NULL, G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG | G_LOG_FLAG_RECURSION | G_LOG_FLAG_FATAL, cl_glib_msg_handler, NULL); /* and for good measure... - this enum is a bit field (!) */ g_log_set_always_fatal((GLogLevelFlags)0); /*value out of range*/ cl_log_set_entity(entity); cl_log_set_facility(HA_LOG_FACILITY); if(coredir) { cl_set_corerootdir(HA_COREDIR); cl_cdtocoredir(); } set_crm_log_level(level); crm_set_env_options(); cl_log_args(argc, argv); cl_log_enable_stderr(to_stderr); CL_SIGNAL(DEBUG_INC, alter_debug); CL_SIGNAL(DEBUG_DEC, alter_debug); return TRUE; }
/* main loop of the daemon*/ int init_start () { int ssock; struct sockaddr_in saddr; GIOChannel* sch; /* register pid */ if (cl_lock_pidfile(PID_FILE) < 0) { quorum_log(LOG_ERR, "already running: [pid %d]." , cl_read_pidfile(PID_FILE)); quorum_log(LOG_ERR, "Startup aborted (already running)." "Shutting down."); exit(100); } register_pid(FALSE, sigterm_action); /* enable coredumps */ quorum_log(LOG_DEBUG, "Enabling coredumps"); cl_cdtocoredir(); cl_enable_coredumps(TRUE); cl_set_all_coredump_signal_handlers(); /* initialize gnutls */ initialize_tls_global(); /* enable dynamic up/down debug level */ G_main_add_SignalHandler(G_PRIORITY_HIGH, SIGUSR1, sig_handler, NULL, NULL); G_main_add_SignalHandler(G_PRIORITY_HIGH, SIGUSR2, sig_handler, NULL, NULL); G_main_add_SignalHandler(G_PRIORITY_HIGH, SIGHUP, sig_handler, NULL, NULL); /* create the mainloop */ mainloop = g_main_new(FALSE); /* create the protocal table */ protocols = g_hash_table_new(g_str_hash, g_str_equal); /* create server socket */ ssock = socket(AF_INET, SOCK_STREAM, 0); if (ssock == -1) { quorum_log(LOG_ERR, "Can not create server socket." "Shutting down."); exit(100); } /* bind server socket*/ memset(&saddr, '\0', sizeof(saddr)); saddr.sin_family = AF_INET; saddr.sin_addr.s_addr = INADDR_ANY; saddr.sin_port = htons(PORT); if (bind(ssock, (struct sockaddr*)&saddr, sizeof(saddr)) == -1) { quorum_log(LOG_ERR, "Can not bind server socket." "Shutting down."); exit(100); } if (listen(ssock, 10) == -1) { quorum_log(LOG_ERR, "Can not start listen." "Shutting down."); exit(100); } /* create source for server socket and add to the mainloop */ sch = g_io_channel_unix_new(ssock); g_io_add_watch(sch, G_IO_IN|G_IO_ERR|G_IO_HUP, on_listen, NULL); /* run the mainloop */ quorum_log(LOG_DEBUG, "main: run the loop..."); quorum_log(LOG_INFO, "Started."); g_main_run(mainloop); /* exit, clean the pid file */ if (cl_unlock_pidfile(PID_FILE) == 0) { quorum_log(LOG_DEBUG, "[%s] stopped", QUORUMD); } return 0; }
int main(int argc, char** argv, char** envp) { int c; gboolean daemonize = FALSE; gboolean stop_logd = FALSE; gboolean ask_status= FALSE; const char* cfgfile = NULL; pid_t pid; cmdname = argv[0]; while ((c = getopt(argc, argv, "c:dksvh")) != -1){ switch(c){ case 'd': /* daemonize */ daemonize = TRUE; break; case 'k': /* stop */ stop_logd = TRUE; break; case 's': /* status */ ask_status = TRUE; break; case 'c': /* config file*/ cfgfile = optarg; break; case 'v': verbose = TRUE; break; case 'h': /*help message */ default: usage(); exit(1); } } set_ipc_time_debug_flag(FALSE); cl_log_set_uselogd(FALSE); if (!cfgfile && access(DEFAULT_CFG_FILE, F_OK) == 0) { cfgfile = DEFAULT_CFG_FILE; } /* default one set to "logd" * by setting facility, we enable syslog */ cl_log_enable_stderr(TRUE); cl_log_set_entity(logd_config.entity); cl_log_set_facility(logd_config.log_facility); if (ask_status){ long pid; if( (pid = cl_read_pidfile(LOGD_PIDFILE)) > 0 ){ printf("logging daemon is running [pid = %ld].\n", pid); exit(LSB_EXIT_OK); }else{ if (pid == - LSB_STATUS_VAR_PID) { printf("logging daemon is stopped: %s exists.\n" , LOGD_PIDFILE); }else{ printf("logging daemon is stopped.\n"); } } exit(-pid); } if (stop_logd){ logd_stop(); exit(LSB_EXIT_OK); } logd_make_daemon(daemonize); if (ipc_channel_pair(chanspair) != IPC_OK){ cl_perror("cannot create channel pair IPC"); return -1; } if (cfgfile && !parse_config(cfgfile)) { FILE* f; if ((f = fopen(cfgfile, "r")) != NULL){ fclose(f); cl_log(LOG_ERR, "Config file [%s] is incorrect." , cfgfile); exit(LSB_EXIT_NOTCONFIGED); } } if (strlen(logd_config.debugfile) > 0) { cl_log_set_debugfile(logd_config.debugfile); } if (strlen(logd_config.logfile) > 0) { cl_log_set_logfile(logd_config.logfile); } cl_log_set_syslogprefix(logd_config.syslogprefix); cl_log_set_entity(logd_config.entity); cl_log_set_facility(logd_config.log_facility); cl_log(LOG_INFO, "logd started with %s.", cfgfile ? cfgfile : "default configuration"); if (cl_enable_coredumps(TRUE) < 0){ cl_log(LOG_ERR, "enabling core dump failed"); } cl_cdtocoredir(); chanspair[WRITE_PROC_CHAN]->ops->set_recv_qlen(chanspair[WRITE_PROC_CHAN], LOGD_QUEUE_LEN); chanspair[READ_PROC_CHAN]->ops->set_send_qlen(chanspair[READ_PROC_CHAN], LOGD_QUEUE_LEN); if (init_set_proc_title(argc, argv, envp) < 0) { cl_log(LOG_ERR, "Allocation of proc title failed."); return -1; } switch(pid = fork()){ case -1: cl_perror("Can't fork child process!"); return -1; case 0: /*child*/ cl_log_use_buffered_io(1); set_proc_title("ha_logd: write process"); write_msg_process(chanspair[WRITE_PROC_CHAN]); break; default: /*parent*/ set_proc_title("ha_logd: read process"); write_process_pid = pid; /* we don't expect to log anything in the parent. */ cl_log_close_log_files(); read_msg_process(chanspair[READ_PROC_CHAN]); break; } return 0; }
static int do_server(int type) { int rv = -1; static char log_ent[128] = DAEMON_NAME "-"; rv = setup_config(type); if (rv < 0) return rv; if (!local) { log_error("Cannot find myself in the configuration."); exit(EXIT_FAILURE); } if (daemonize) { if (daemon(0, 0) < 0) { perror("daemon error"); exit(EXIT_FAILURE); } } /* The lockfile must be written to _after_ the call to daemon(), so * that the lockfile contains the pid of the daemon, not the parent. */ lock_fd = create_lockfile(); if (lock_fd < 0) return lock_fd; atexit(server_exit); strcat(log_ent, type_to_string(local->type)); cl_log_set_entity(log_ent); cl_log_enable_stderr(enable_stderr ? TRUE : FALSE); cl_log_set_facility(HA_LOG_FACILITY); cl_inherit_logging_environment(0); log_info("BOOTH %s %s daemon is starting", type_to_string(local->type), RELEASE_STR); signal(SIGUSR1, (__sighandler_t)tickets_log_info); signal(SIGTERM, (__sighandler_t)sig_exit_handler); signal(SIGINT, (__sighandler_t)sig_exit_handler); /* we'll handle errors there and then */ signal(SIGPIPE, SIG_IGN); set_scheduler(); /* we don't want to be killed by the OOM-killer */ if (set_procfs_val("/proc/self/oom_score_adj", "-999")) (void)set_procfs_val("/proc/self/oom_adj", "-16"); set_proc_title("%s %s %s for [%s]:%d", DAEMON_NAME, cl.configfile, type_to_string(local->type), local->addr_string, booth_conf->port); rv = limit_this_process(); if (rv) return rv; #ifdef COREDUMP_NURSING if (cl_enable_coredumps(TRUE) < 0){ log_error("enabling core dump failed"); } cl_cdtocoredir(); prctl(PR_SET_DUMPABLE, (unsigned long)TRUE, 0UL, 0UL, 0UL); #else if (chdir(BOOTH_CORE_DIR) < 0) { log_error("cannot change working directory to %s", BOOTH_CORE_DIR); } #endif signal(SIGCHLD, (__sighandler_t)wait_child); rv = loop(lock_fd); return rv; }
int main(int argc, char *argv[]) { int rc; int retval = 0; const char* conf_file = CONFIG_FILE; int pid; cl_cdtocoredir(); if(argc == 2){ conf_file = argv[1]; }else if(argc > 2){ printf("Usage: %s [config_file]\n", cmdname); exit(LSB_EXIT_NOTCONFIGED); } cl_log_enable_stderr(TRUE); pid = cl_read_pidfile(PIDFILE); if (pid > 0 && pid != getpid()){ cl_log(LOG_INFO, "recovermgrd is already running[%d]", pid); return 0; } cl_log_set_entity(argv[0]); cl_log_set_facility(LOG_USER); cl_log(LOG_INFO, "Starting %s", argv[0]); signal(SIGCHLD, sigchld_handler); if(parseConfigFile(conf_file) == FALSE){ exit(LSB_EXIT_NOTCONFIGED); }; /* make self a daemon */ #ifndef DEBUG daemon(0,0); #else printf("Debug mode -- non daemon\n"); #endif if (cl_lock_pidfile(PIDFILE) < 0){ cl_log(LOG_INFO, "recoverymgrd is already running[%d]", cl_read_pidfile(PIDFILE)); return 0; } /* register with apphbd as a client and send pings */ retval = register_hb(); if (0 != retval) { cl_perror("Error registering -- is apphbd running??"); exit(retval); } create_connection(); /* unregister and shutdown */ rc = apphb_unregister(); if (rc < 0) { cl_perror("apphb_unregister failure"); exit(3); } cl_unlock_pidfile(PIDFILE); return 0; }
static int do_server(int type) { int rv = -1; static char log_ent[128] = DAEMON_NAME "-"; rv = setup_config(type); if (rv < 0) return rv; if (!local) { log_error("Cannot find myself in the configuration."); exit(EXIT_FAILURE); } if (!daemonize) { if (daemon(0, 0) < 0) { perror("daemon error"); exit(EXIT_FAILURE); } } /* The lockfile must be written to _after_ the call to daemon(), so * that the lockfile contains the pid of the daemon, not the parent. */ lock_fd = create_lockfile(); if (lock_fd < 0) return lock_fd; atexit(server_exit); strcat(log_ent, type_to_string(local->type)); cl_log_set_entity(log_ent); cl_log_enable_stderr(enable_stderr ? TRUE : FALSE); cl_log_set_facility(HA_LOG_FACILITY); cl_inherit_logging_environment(0); log_info("BOOTH %s %s daemon is starting", type_to_string(local->type), RELEASE_STR); signal(SIGUSR1, (__sighandler_t)tickets_log_info); signal(SIGTERM, (__sighandler_t)sig_exit_handler); signal(SIGINT, (__sighandler_t)sig_exit_handler); set_scheduler(); set_oom_adj(-16); set_proc_title("%s %s %s for [%s]:%d", DAEMON_NAME, cl.configfile, type_to_string(local->type), local->addr_string, booth_conf->port); rv = limit_this_process(); if (rv) return rv; if (cl_enable_coredumps(TRUE) < 0){ cl_log(LOG_ERR, "enabling core dump failed"); } cl_cdtocoredir(); prctl(PR_SET_DUMPABLE, (unsigned long)TRUE, 0UL, 0UL, 0UL); rv = loop(lock_fd); return rv; }