| /* | |
| * stpgd_main.c | |
| */ | |
| #include <fcntl.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <getopt.h> | |
| #include <malloc.h> | |
| #include <inttypes.h> | |
| #include <sys/wait.h> | |
| #include <poll.h> | |
| #include <sys/ioctl.h> | |
| #include <stdbool.h> | |
| #include <stdio.h> | |
| #include <pthread.h> | |
| #include <unistd.h> | |
| #include <syslog.h> | |
| #include <signal.h> | |
| #include <syslog.h> | |
| #include "version.h" | |
| #include "debug.h" | |
| #include "scst_event.h" | |
| char *app_name; | |
| #define DEFAULT_TRANSITION_TIME 17 | |
| #if defined(DEBUG) || defined(TRACING) | |
| #ifdef DEBUG | |
| #define DEFAULT_LOG_FLAGS (TRACE_OUT_OF_MEM | TRACE_MINOR | TRACE_PID | \ | |
| TRACE_FUNCTION | TRACE_SPECIAL | TRACE_MGMT | TRACE_MGMT_DEBUG | \ | |
| TRACE_TIME) | |
| #define TRACE_SN(args...) TRACE(TRACE_SCSI_SERIALIZING, args) | |
| #else /* DEBUG */ | |
| # ifdef TRACING | |
| #define DEFAULT_LOG_FLAGS (TRACE_OUT_OF_MEM | TRACE_MGMT | \ | |
| TRACE_TIME | TRACE_SPECIAL) | |
| # else | |
| #define DEFAULT_LOG_FLAGS 0 | |
| # endif | |
| #endif /* DEBUG */ | |
| unsigned long trace_flag = DEFAULT_LOG_FLAGS; | |
| #endif /* defined(DEBUG) || defined(TRACING) */ | |
| #define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0])) | |
| bool log_daemon = true; | |
| int transition_timeout = DEFAULT_TRANSITION_TIME; | |
| static struct option const long_options[] = { | |
| {"path", required_argument, 0, 'p'}, | |
| {"timeout", required_argument, 0, 't'}, | |
| {"foreground", no_argument, 0, 'f'}, | |
| #if defined(DEBUG) || defined(TRACING) | |
| {"debug", required_argument, 0, 'd'}, | |
| #endif | |
| {"version", no_argument, 0, 'v'}, | |
| {"help", no_argument, 0, 'h'}, | |
| {0, 0, 0, 0}, | |
| }; | |
| int stpg_init_report_pipe[2]; | |
| char *stpg_path; | |
| static void usage(int status) | |
| { | |
| if (status != 0) | |
| fprintf(stderr, "Try '%s --help' for more information.\n", app_name); | |
| else { | |
| printf("Usage: %s [OPTIONS]\n", app_name); | |
| printf("STPG target daemon\n"); | |
| printf(" -f, --foreground make the program run in the foreground\n"); | |
| printf(" -p, --path absolute path to the STPG script\n"); | |
| printf(" -t, --timeout transition timeout\n"); | |
| #if defined(DEBUG) || defined(TRACING) | |
| printf(" -d, --debug=level debug tracing level\n"); | |
| #endif | |
| printf(" -h, --help display this help and exit\n"); | |
| } | |
| } | |
| static void stpg_handle_tm_received(struct scst_event_user *event_user) | |
| { | |
| /* | |
| * Put code to abort state transition here, if this STPG cmd, | |
| * identified by cmd_to_abort_tag or RESET, requested to be aborted | |
| */ | |
| } | |
| static int invoke_stpg(const uint8_t *device_name, | |
| const struct scst_event_stpg_descr *descr, pid_t *out_pid) | |
| { | |
| char *args[7], *env[7]; | |
| int res = 0, ret, i; | |
| pid_t c_pid; | |
| args[0] = stpg_path; | |
| args[1] = (char *)device_name; | |
| args[2] = (char *)descr->prev_state; | |
| args[3] = (char *)descr->new_state; | |
| args[4] = (char *)descr->dg_name; | |
| args[5] = (char *)descr->tg_name; | |
| args[6] = NULL; | |
| env[0] = "PATH=/bin:/usr/bin:/sbin:/usr/sbin"; | |
| ret = asprintf(&env[1], "SCST_DEVICE_NAME=%s", device_name); | |
| if (ret < 0) { | |
| res = -errno; | |
| PRINT_ERROR("asprintf() failed: %d (%s)", res, strerror(-res)); | |
| goto out; | |
| } | |
| ret = asprintf(&env[2], "SCST_PREV_ALUA_STATE=%s", descr->prev_state); | |
| if (ret < 0) { | |
| res = -errno; | |
| PRINT_ERROR("asprintf() failed: %d (%s)", res, strerror(-res)); | |
| goto out; | |
| } | |
| ret = asprintf(&env[3], "SCST_ALUA_STATE=%s", descr->new_state); | |
| if (ret < 0) { | |
| res = -errno; | |
| PRINT_ERROR("asprintf() failed: %d (%s)", res, strerror(-res)); | |
| goto out; | |
| } | |
| ret = asprintf(&env[4], "SCST_DEVICE_GROUP=%s", descr->dg_name); | |
| if (ret < 0) { | |
| res = -errno; | |
| PRINT_ERROR("asprintf() failed: %d (%s)", res, strerror(-res)); | |
| goto out; | |
| } | |
| ret = asprintf(&env[5], "SCST_TARGET_GROUP=%s", descr->tg_name); | |
| if (ret < 0) { | |
| res = -errno; | |
| PRINT_ERROR("asprintf() failed: %d (%s)", res, strerror(-res)); | |
| goto out; | |
| } | |
| env[6] = NULL; | |
| PRINT_INFO("Invoking script %s with parameters: %s %s %s %s %s and environment: " | |
| "%s %s %s %s %s", stpg_path, args[1], args[2], args[3], | |
| args[4], args[5], env[1], env[2], env[3], env[4], env[5]); | |
| c_pid = fork(); | |
| if (c_pid == 0) { | |
| ret = setpgid(getpid(), getpid()); | |
| if (ret < 0) { | |
| res = -errno; | |
| PRINT_ERROR("setgid failed %d (%s)", ret, strerror(-ret)); | |
| } | |
| TRACE_DBG("pgid %d (pid %d)", getpgid(getpid()), getpid()); | |
| ret = execve(stpg_path, args, env); | |
| if (ret < 0) { | |
| res = -errno; | |
| PRINT_ERROR("EXEC failed %d (%s)", ret, strerror(-ret)); | |
| } | |
| exit(0); | |
| } else if (c_pid < 0) { | |
| res = -errno; | |
| PRINT_ERROR("fork() failed: %d (%s)", res, strerror(-res)); | |
| } | |
| *out_pid = c_pid; | |
| for (i = 1; i < (signed)ARRAY_SIZE(env); i++) | |
| free(env[i]); | |
| out: | |
| return res; | |
| } | |
| /* Returns 0, if the pid is still running, >0 if it was exited or <0 error code */ | |
| static int wait_until_finished(pid_t pid, unsigned long deadline, int *status, int child) | |
| { | |
| int res; | |
| time_t start, end; | |
| double elapsed; | |
| TRACE_ENTRY(); | |
| time(&start); | |
| do { | |
| res = waitpid(pid, status, WNOHANG); | |
| if (res != 0) { | |
| if (res < 0) { | |
| res = -errno; | |
| PRINT_ERROR("Waitpid for pid %d (child %d) " | |
| "failed: %d (%s)", pid, child, | |
| errno, strerror(errno)); | |
| } | |
| break; | |
| } | |
| usleep(100*1000); | |
| time(&end); | |
| elapsed = difftime(end, start); | |
| } while (elapsed < deadline); | |
| TRACE_EXIT_RES(res); | |
| return res; | |
| } | |
| static int handle_stpg_received(struct scst_event_user *event_user) | |
| { | |
| const struct scst_event_stpg_payload *p = (struct scst_event_stpg_payload *)event_user->out_event.payload; | |
| int num, k; | |
| int res = 0; | |
| pid_t pids[p->stpg_descriptors_cnt]; | |
| TRACE_DBG("device name %s, stpg_descriptors_cnt %d", p->device_name, | |
| p->stpg_descriptors_cnt); | |
| for (num = 0; num < p->stpg_descriptors_cnt; num++) { | |
| res = invoke_stpg(p->device_name, &p->stpg_descriptors[num], &pids[num]); | |
| TRACE_DBG("num %d, res %d, pid %d", num, res, pids[num]); | |
| if (res != 0) | |
| break; | |
| } | |
| TRACE_DBG("num %d", num); | |
| for (k = 0; k < num; k++) { | |
| int status = 0, rc; | |
| TRACE_DBG("k %d, pid %d", k, pids[k]); | |
| rc = wait_until_finished(pids[k], transition_timeout, &status, k); | |
| TRACE_DBG("rc %d, status %d", rc, WEXITSTATUS(status)); | |
| if (rc > 0) { | |
| if (res == 0) | |
| res = WEXITSTATUS(status); | |
| continue; | |
| } else if (rc < 0) { | |
| if (res == 0) | |
| res = rc; | |
| continue; | |
| } | |
| PRINT_WARNING("on_stpg %d (pid %d) did not finish on time - " | |
| "sending SIGTERM", k, pids[k]); | |
| if (res == 0) | |
| res = -ETIMEDOUT; | |
| rc = killpg(pids[k], SIGTERM); | |
| if (rc < 0) | |
| PRINT_ERROR("Failed to send SIGTERM to child %d (pid %d): %d/%s", | |
| k, pids[k], errno, strerror(errno)); | |
| rc = wait_until_finished(pids[k], 1, &status, k); | |
| if (rc != 0) | |
| continue; | |
| while (1) { | |
| PRINT_WARNING("on_stpg %d (pid %d) did not finish on time - " | |
| "sending SIGKILL", k, pids[k]); | |
| rc = killpg(pids[k], SIGKILL); | |
| if (rc < 0) { | |
| PRINT_ERROR("Failed to send SIGKILL to child %d " | |
| "(pid %d): %d/%s", k, pids[k], errno, | |
| strerror(errno)); | |
| break; | |
| } | |
| rc = wait_until_finished(pids[k], 1, &status, k); | |
| if (rc != 0) | |
| break; | |
| }; | |
| } | |
| TRACE_EXIT_RES(res); | |
| return res; | |
| } | |
| static int stpg_event_loop(void) | |
| { | |
| int res = 0, status; | |
| int event_fd; | |
| uint8_t event_user_buf[1024*1024]; | |
| pid_t c_pid = 0; | |
| struct pollfd pl; | |
| struct scst_event_user *event_user = | |
| (struct scst_event_user *)event_user_buf; | |
| struct scst_event e1; | |
| bool first_error = true; | |
| event_fd = open(SCST_EVENT_DEV, O_RDWR); | |
| if (event_fd < 0) { | |
| res = -errno; | |
| PRINT_ERROR("Unable to open SCST event device %s (%s)", | |
| SCST_EVENT_DEV, strerror(-res)); | |
| goto out; | |
| } | |
| close(stpg_init_report_pipe[0]); | |
| if (log_daemon) | |
| res = write(stpg_init_report_pipe[1], &res, sizeof(res)); | |
| close(stpg_init_report_pipe[1]); | |
| memset(&pl, 0, sizeof(pl)); | |
| pl.fd = event_fd; | |
| pl.events = POLLIN; | |
| memset(&e1, 0, sizeof(e1)); | |
| e1.event_code = SCST_EVENT_STPG_USER_INVOKE; | |
| strncpy(e1.issuer_name, SCST_EVENT_SCST_CORE_ISSUER, | |
| sizeof(e1.issuer_name)); | |
| e1.issuer_name[sizeof(e1.issuer_name)-1] = '\0'; | |
| PRINT_INFO("Setting allowed event code %d, issuer_name %s", | |
| e1.event_code, e1.issuer_name); | |
| res = ioctl(event_fd, SCST_EVENT_ALLOW_EVENT, &e1); | |
| if (res != 0) { | |
| res = -errno; | |
| PRINT_ERROR("SCST_EVENT_ALLOW_EVENT failed: %d (%s)", | |
| res, strerror(-res)); | |
| goto out; | |
| } | |
| e1.event_code = SCST_EVENT_TM_FN_RECEIVED; | |
| strncpy(e1.issuer_name, SCST_EVENT_SCST_CORE_ISSUER, | |
| sizeof(e1.issuer_name)); | |
| e1.issuer_name[sizeof(e1.issuer_name)-1] = '\0'; | |
| PRINT_INFO("Setting allowed event code %d, issuer_name %s", | |
| e1.event_code, e1.issuer_name); | |
| res = ioctl(event_fd, SCST_EVENT_ALLOW_EVENT, &e1); | |
| if (res != 0) { | |
| res = -errno; | |
| PRINT_ERROR("SCST_EVENT_ALLOW_EVENT failed: %d (%s)", | |
| res, strerror(-res)); | |
| goto out; | |
| } | |
| while (1) { | |
| memset(event_user_buf, 0, sizeof(event_user_buf)); | |
| event_user->max_event_size = sizeof(event_user_buf); | |
| res = ioctl(event_fd, SCST_EVENT_GET_NEXT_EVENT, event_user); | |
| if (res != 0) { | |
| res = -errno; | |
| switch (-res) { | |
| case ESRCH: | |
| case EBUSY: | |
| TRACE_MGMT_DBG("SCST_EVENT_GET_NEXT_EVENT " | |
| "returned %d (%s)", res, strerror(res)); | |
| /* fall through */ | |
| case EINTR: | |
| continue; | |
| case EAGAIN: | |
| TRACE_DBG("SCST_EVENT_GET_NEXT_EVENT, " | |
| "returned EAGAIN (%d)", -res); | |
| continue; | |
| default: | |
| PRINT_ERROR("SCST_EVENT_GET_NEXT_EVENT " | |
| "failed: %d (%s)", res, strerror(-res)); | |
| if (!first_error) | |
| goto out; | |
| first_error = false; | |
| continue; | |
| } | |
| first_error = true; | |
| again_poll: | |
| res = poll(&pl, 1, c_pid > 0 ? 1 : 0); | |
| if (res > 0) | |
| continue; | |
| else if (res == 0) | |
| goto again_poll; | |
| else { | |
| res = -errno; | |
| switch (res) { | |
| case ESRCH: | |
| case EBUSY: | |
| case EAGAIN: | |
| TRACE_MGMT_DBG("poll() returned %d " | |
| "(%s)", res, strerror(-res)); | |
| case EINTR: | |
| goto again_poll; | |
| default: | |
| PRINT_ERROR("poll() failed: %d (%s)", | |
| res, strerror(-res)); | |
| goto again_poll; | |
| } | |
| } | |
| } | |
| first_error = true; | |
| #ifdef DEBUG | |
| PRINT_INFO("event_code %d, issuer_name %s", | |
| event_user->out_event.event_code, | |
| event_user->out_event.issuer_name); | |
| #endif | |
| if (event_user->out_event.payload_len != 0) | |
| TRACE_BUFFER("payload", event_user->out_event.payload, | |
| event_user->out_event.payload_len); | |
| if (event_user->out_event.event_code == SCST_EVENT_STPG_USER_INVOKE) { | |
| c_pid = fork(); | |
| if (c_pid == -1) | |
| PRINT_ERROR("Failed to fork: %d", c_pid); | |
| else if (c_pid == 0) { | |
| struct scst_event_notify_done d; | |
| signal(SIGCHLD, SIG_DFL); | |
| status = handle_stpg_received(event_user); | |
| memset(&d, 0, sizeof(d)); | |
| d.event_id = event_user->out_event.event_id; | |
| d.status = status; | |
| res = ioctl(event_fd, SCST_EVENT_NOTIFY_DONE, &d); | |
| if (res != 0) { | |
| res = -errno; | |
| PRINT_ERROR("SCST_EVENT_NOTIFY_DONE " | |
| "failed: %s (res %d)", | |
| strerror(-res), res); | |
| } else | |
| PRINT_INFO("STPG event completed with status %d", status); | |
| exit(res); | |
| } | |
| } else if (event_user->out_event.event_code == SCST_EVENT_TM_FN_RECEIVED) | |
| stpg_handle_tm_received(event_user); | |
| else | |
| PRINT_ERROR("Unknown event %d received", event_user->out_event.event_code); | |
| } | |
| out: | |
| return res; | |
| } | |
| static void sig_chld(int signal) | |
| { | |
| /* Check just in case */ | |
| if (signal == SIGCHLD) { | |
| TRACE_DBG("Cleanup zombie (pid %d)", getpid()); | |
| wait(NULL); | |
| } | |
| } | |
| int main(int argc, char **argv) | |
| { | |
| int res = 0, ch, longindex; | |
| pid_t pid; | |
| struct sigaction sa; | |
| setlinebuf(stdout); | |
| openlog(argv[0], LOG_PID, LOG_USER); | |
| res = pipe(stpg_init_report_pipe); | |
| if (res == -1) { | |
| res = -errno; | |
| PRINT_ERROR("Pipe failed: %d (%s)", res, strerror(-res)); | |
| goto out; | |
| } | |
| sa.sa_handler = &sig_chld; | |
| sigemptyset(&sa.sa_mask); | |
| sa.sa_flags = SA_RESTART | SA_NOCLDSTOP; | |
| if (sigaction(SIGCHLD, &sa, 0) == -1) { | |
| PRINT_ERROR("sigaction() failed: %d/%s", errno, strerror(errno)); | |
| exit(1); | |
| } | |
| /* | |
| * Otherwise we could die in some later write() during the event_loop() | |
| * instead of getting EPIPE! | |
| */ | |
| signal(SIGPIPE, SIG_IGN); | |
| res = debug_init(); | |
| if (res != 0) | |
| goto out; | |
| app_name = argv[0]; | |
| while ((ch = getopt_long(argc, argv, "+d:fp:t:hv", | |
| long_options, &longindex)) >= 0) { | |
| switch (ch) { | |
| case 'p': | |
| stpg_path = optarg; | |
| break; | |
| #if defined(DEBUG) || defined(TRACING) | |
| case 'd': | |
| trace_flag = strtol(optarg, (char **)NULL, 0); | |
| break; | |
| #endif | |
| case 'v': | |
| printf("%s version %s\n", app_name, VERSION_STR); | |
| goto out_done; | |
| case 'f': | |
| log_daemon = false; | |
| break; | |
| case 't': | |
| transition_timeout = strtol(optarg, (char **)NULL, 0); | |
| if (transition_timeout < 0) { | |
| printf("Invalid timeout %d\n", transition_timeout); | |
| res = -EINVAL; | |
| goto out_done; | |
| } | |
| break; | |
| case 'h': | |
| usage(0); | |
| goto out_done; | |
| default: | |
| goto out_usage; | |
| } | |
| } | |
| if (!stpg_path) | |
| stpg_path = "/usr/local/bin/scst/scst_on_stpg"; | |
| if (access(stpg_path, X_OK) == -1) { | |
| PRINT_ERROR("Script file \" %s \"does not exist or not " | |
| "executable", stpg_path); | |
| res = -1; | |
| goto out_done; | |
| } | |
| #ifdef DEBUG | |
| PRINT_INFO("trace_flag %lx", trace_flag); | |
| #endif | |
| if (log_daemon) { | |
| #if defined(DEBUG) || defined(TRACING) | |
| trace_flag &= ~TRACE_TIME; | |
| trace_flag &= ~TRACE_PID; | |
| #endif | |
| pid = fork(); | |
| if (pid < 0) { | |
| PRINT_ERROR("starting daemon failed(%d)", pid); | |
| res = pid; | |
| goto out_done; | |
| } else if (pid) { | |
| int res1 = -1; | |
| close(stpg_init_report_pipe[1]); | |
| if ((unsigned)read(stpg_init_report_pipe[0], &res1, sizeof(res1)) < sizeof(res1)) { | |
| res = -1; | |
| goto out_done; | |
| } else { | |
| res = res1; | |
| goto out_done; | |
| } | |
| } | |
| close(0); | |
| open("/dev/null", O_RDWR); | |
| dup2(0, 1); | |
| dup2(0, 2); | |
| setsid(); | |
| } | |
| res = stpg_event_loop(); | |
| out_done: | |
| debug_done(); | |
| out: | |
| closelog(); | |
| return res; | |
| out_usage: | |
| usage(1); | |
| goto out_done; | |
| } |