How are reboot handle when a process is still running

Question

Here's the situation. I'm debugging a code to do a logging function. When the user log in, the log file will be create with .part format. This file is save locally inside the host. I do not know why it's name as .part. When the user finish their session, the log file will be rename as .username only. Beside the local log file, this code is also connected to a server where this server will also save the logging file. The problem is when the logging is still running, but the host suddenly reboot. The reboot might be caused by command from root, or a force reboot, or maybe a hardware fault. This causes the logging file to stay as .part and the server also follows.

So, my question is:

How to make it rename the file before the process is killed or terminated during reboot?

Whats the signal that I should handle?

I'm thinking this might involve a race condition, is there a way for me to delay the reboot?

My approach

tried to handle SIGPWR,SIGSTOP,SIGTERM,SIGQUIT

create a bash script to do renaming when the process start.

Here is the main code:

int main(int argc, char **argv)
{
    int ch;
    int NoFork = 0;
    struct event_config *evconfig;
    struct event *signal_event_int;
    struct event *signal_event_quit;
    struct event *signal_event_term;
    struct event *signal_event_hup;
    struct event *signal_event_chld;
    struct event *signal_event_pwr;
    struct event *signal_event_stop;

    syspath_init_from_argv0(argv[0]);

    load_config();    /* load config first, the command line parameters will override */
    event_set_log_callback(my_event_log_cb);

    evconfig = event_config_new();
    if (event_config_require_features(evconfig, EV_FEATURE_FDS)!=0) {
            log_error("event_config_require_features_failed");
    }
    while (!done) {
            /* ignore HUP first, just in case someone send us a HUP
               when we are reloading config, that will create a condition
               that makes us exit, with HangUp */
            sig_catch(SIGHUP,SIG_IGN);
            base = event_base_new_with_config(evconfig);

            local_listener = create_local_listener(base);

            if (!local_listener) {
                    log_error("Could not create a local listener!");
                    return 1;
            }
            http_listener = create_http_listener();
            if (!http_listener) {
                    log_error("Could not create a remote listener!");
                    return 1;
            }
            evhttp_set_cb(http_listener, "/mrexec", http_mrexec_cb, NULL);
            if (options.accept_remote) {
                    evhttp_set_cb(http_listener, "/rlog", http_rlog_cb, NULL);
            }
            if (pidfile_create(ACTSLOGD_PIDFILE)==-1) {
                    log_error("pidfile_create:failed:%d:%s", errno, strerror(errno));
            }
            LIST_INIT(&clientlist);
            if (options.log_remote) {
                    start_log_remote();
            }

            signal_event_int = evsignal_new(base, SIGINT, exit_cb, (void *)base);
            event_add(signal_event_int, NULL);
            signal_event_quit = evsignal_new(base, SIGQUIT, exit_cb, (void *)base);
            event_add(signal_event_quit, NULL);
            signal_event_term = evsignal_new(base, SIGTERM, exit_cb, (void *)base);
            event_add(signal_event_term, NULL);
            signal_event_hup = evsignal_new(base, SIGHUP, reload_config_cb, (void *)base);
            event_add(signal_event_hup, NULL);
            signal_event_chld = evsignal_new(base, SIGCHLD, sigchld_cb, (void *)base);
            event_add(signal_event_chld, NULL);
            signal_event_pwr = evsignal_new(base, SIGPWR, power_off_cb, (void *)base);
            event_add(signal_event_pwr, NULL);
            signal_event_stop = evsignal_new(base, SIGSTOP, power_off_cb, (void *)base);
            event_add(signal_event_chld, NULL);

            actslog_event_start(AGENT_ACTSLOGD);
            actslog_event_start(AGENT_ESCALATED);
            event_base_dispatch(base);
            printf("finished dispatch
");

            evconnlistener_free(local_listener);

            evhttp_free(http_listener);
            http_listener = NULL;

            event_free(signal_event_int);
            event_free(signal_event_quit);
            event_free(signal_event_term);
            event_free(signal_event_hup);
            event_free(signal_event_pwr);
            event_free(signal_event_stop);

            if (options.log_remote) {
                    end_log_remote();
            }
            event_base_free(base);
            if (!done) {
                    load_config();
            }
            while (clientlist.lh_first != NULL) {
                    struct bufferevent *bev = clientlist.lh_first->bev;
                    bufferevent_free(bev);
                    LIST_REMOVE(clientlist.lh_first, clients);
            }
    }
    if (rlog) {
            rlog_close(rlog);
    }
    unlink(PATH_ACTSLOG);
    pidfile_cleanup(ACTSLOGD_PIDFILE);

    return 0;
}

This is the signal handler

static void exit_cb(evutil_socket_t sig, short events, void *user_data)
{
    struct event_base *base = user_data;
    struct timeval delay = { 2, 0 };

    actslog_event_stop(AGENT_ACTSLOGD);
    actslog_event_stop(AGENT_ESCALATED);

    done = 1;    //when this is 1, there is a function that will connect to the server to tell that the logging is stopped.

    /* need to give some delay for us to send out the stop message to Logger */

    event_base_loopexit(base, &delay);
}

static void power_off_cb(evutil_socket_t sig, short events, void *user_data)
{
    struct event_base *base = user_data;
    struct timeval delay = { 5, 0 };
    char logfile_partial[MAXPATHLEN];
    char logfile_complete[MAXPATHLEN];
    char id[1024];

    done =1;     

    event_base_loopexit(base,&delay);

    snprintf(logfile_partial,    //the logfile_partial will be the one with .part file
    sizeof(logfile_partial),
    "%s/SHELL.%s.part", logpath2, id);

    snprintf(logfile_complete,   //the logfile_complete will be the complete without .part
    sizeof(logfile_complete),
    "%s/SHELL.%s", logpath2, id);

    if (rename(logfile_partial, logfile_complete)!=0) {
            if (errno==ENOENT) {
                    int tmp;
                    log_error("mastershell [%s] log is incomplete", logfile_complete);
                    tmp = creat(logfile_complete, LOG_FILE_MODE);
                    if (tmp==-1) {
                            log_error("creat:%s:failed:%d:%s!!
", logfile_complete, errno, strerror(errno));
                    } else {
                    close(tmp);
                    }
            } else {
            log_error("rename:%s:%s:failed:%d:%s!!
", logfile_partial, logfile_complete, errno, strerror(errno));
            }
    }

    if (rlog) {
            rlog_close(rlog);
    }
    unlink(PATH_ACTSLOG);
    pidfile_cleanup(ACTSLOGD_PIDFILE);
}

I have tested to handle all signal in exit_cb function. Also all signals inside power_off_cb function. Neither one of them works. I have tested on CentOS and Ubuntu. The logging process is a upstart process. Any comment or suggestion are really appreciated.

How are reboot handle when a process is still running

Answers (1)

Related Questions