X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=server.c;h=13c8c85f98339023b90415125e9df275a28c98f3;hp=43ede2a91b752667ad4090e2742c4a844bf66250;hb=7f08e8b0eb9570f1eb787dbb4e10d56585b36bbf;hpb=1f12ea375358a0b30689e01efe82796ea4fcb14f diff --git a/server.c b/server.c index 43ede2a9..13c8c85f 100644 --- a/server.c +++ b/server.c @@ -1,8 +1,4 @@ -/* - * Copyright (C) 1997 Andre Noll - * - * Licensed under the GPL v2. For licencing details see COPYING. - */ +/* Copyright (C) 1997 Andre Noll , see file COPYING. */ /** \file server.c Paraslash's main server. */ @@ -90,7 +86,15 @@ struct lls_parse_result *server_lpr = NULL; /* Command line options (no config file options). Used in handle_sighup(). */ static struct lls_parse_result *cmdline_lpr; -/** A random value used in child context for authentication. */ +/** + * A random number used to "authenticate" the afs connection. + * + * para_server picks this number by random before it forks the afs process. The + * command handlers know this number as well and write it to the afs socket, + * together with the id of the shared memory area which contains the payload of + * the afs command. A local process has to know this number to abuse the afs + * service provided by the local socket. + */ uint32_t afs_socket_cookie; /** The mutex protecting the shared memory area containing the mmd struct. */ @@ -99,10 +103,33 @@ int mmd_mutex; static struct sched sched; static struct signal_task *signal_task; +/** The process id of the audio file selector process. */ +pid_t afs_pid = 0; + +/* The the main server process (parent of afs and the command handlers). */ +static pid_t server_pid; + +/** + * Tell whether the executing process is a command handler. + * + * Cleanup on exit must be performed differently for command handlers. + * + * \return True if the pid of the executing process is neither the server pid + * nor the afs pid. + */ +bool process_is_command_handler(void) +{ + pid_t pid = getpid(); + + return pid != afs_pid && pid != server_pid; +} + /** The task responsible for server command handling. */ struct server_command_task { /** TCP port on which para_server listens for connections. */ int listen_fd; + /* File descriptor for the accepted socket. */ + int child_fd; /** Copied from para_server's main function. */ int argc; /** Argument vector passed to para_server's main function. */ @@ -178,12 +205,11 @@ void parse_config_or_die(bool reload) struct lls_parse_result *cf_lpr, *merged_lpr; char *home = para_homedir(); - daemon_close_log(); if (OPT_GIVEN(CONFIG_FILE)) cf = para_strdup(OPT_STRING_VAL(CONFIG_FILE)); else cf = make_message("%s/.paraslash/server.conf", home); - if (!mmd || getpid() != mmd->afs_pid) { + if (!mmd || getpid() != afs_pid) { if (OPT_GIVEN(USER_LIST)) user_list_file = para_strdup(OPT_STRING_VAL(USER_LIST)); else @@ -196,7 +222,6 @@ void parse_config_or_die(bool reload) goto free_cf; if (ret == -ERRNO_TO_PARA_ERROR(ENOENT) && OPT_GIVEN(CONFIG_FILE)) goto free_cf; - ret = 0; server_lpr = cmdline_lpr; goto success; } @@ -212,7 +237,7 @@ void parse_config_or_die(bool reload) if (reload) /* config file overrides command line */ ret = lls(lls_merge(cf_lpr, cmdline_lpr, CMD_PTR, &merged_lpr, &errctx)); - else /* command line options overrride config file options */ + else /* command line options override config file options */ ret = lls(lls_merge(cmdline_lpr, cf_lpr, CMD_PTR, &merged_lpr, &errctx)); lls_free_parse_result(cf_lpr, CMD_PTR); @@ -263,14 +288,18 @@ static void handle_sighup(void) PARA_NOTICE_LOG("SIGHUP\n"); parse_config_or_die(true); - if (mmd->afs_pid) - kill(mmd->afs_pid, SIGHUP); + if (afs_pid != 0) + kill(afs_pid, SIGHUP); } static int signal_post_select(struct sched *s, __a_unused void *context) { - int signum = para_next_signal(&s->rfds); + int ret, signum; + ret = task_get_notification(signal_task->task); + if (ret < 0) + return ret; + signum = para_next_signal(&s->rfds); switch (signum) { case 0: return 0; @@ -280,10 +309,10 @@ static int signal_post_select(struct sched *s, __a_unused void *context) case SIGCHLD: for (;;) { pid_t pid; - int ret = para_reap_child(&pid); + ret = para_reap_child(&pid); if (ret <= 0) break; - if (pid != mmd->afs_pid) + if (pid != afs_pid) continue; PARA_EMERG_LOG("fatal: afs died\n"); kill(0, SIGTERM); @@ -296,27 +325,22 @@ static int signal_post_select(struct sched *s, __a_unused void *context) PARA_EMERG_LOG("terminating on signal %d\n", signum); kill(0, SIGTERM); /* - * We must wait for afs because afs catches SIGINT/SIGTERM. - * Before reacting to the signal, afs might want to use the + * We must wait for all of our children to die. For the afs + * process or a command handler might want to use the * shared memory area and the mmd mutex. If we destroy this * mutex too early and afs tries to lock the shared memory * area, the call to mutex_lock() will fail and terminate the * afs process. This leads to dirty osl tables. - * - * There's no such problem with the other children of the - * server process (the command handlers) as these reset their - * SIGINT/SIGTERM handlers to the default action, i.e. these - * processes get killed immediately by the above kill(). */ - PARA_INFO_LOG("waiting for afs (pid %d) to die\n", - (int)mmd->afs_pid); - waitpid(mmd->afs_pid, NULL, 0); + PARA_INFO_LOG("waiting for child processes to die\n"); + mutex_unlock(mmd_mutex); + while (wait(NULL) != -1 || errno != ECHILD) + ; /* still at least one child alive */ + mutex_lock(mmd_mutex); cleanup: free(mmd->afd.afhi.chunk_table); - close_listed_fds(); - mutex_destroy(mmd_mutex); - shm_detach(mmd); - exit(EXIT_FAILURE); + task_notify_all(s, E_DEADLY_SIGNAL); + return -E_DEADLY_SIGNAL; } return 0; } @@ -348,17 +372,17 @@ static void command_pre_select(struct sched *s, void *context) static int command_post_select(struct sched *s, void *context) { struct server_command_task *sct = context; - int new_fd, ret, i; char *peer_name; pid_t child_pid; uint32_t *chunk_table; + ret = task_get_notification(sct->task); + if (ret < 0) + return ret; ret = para_accept(sct->listen_fd, &s->rfds, NULL, 0, &new_fd); if (ret <= 0) goto out; - peer_name = remote_name(new_fd); - PARA_INFO_LOG("got connection from %s, forking\n", peer_name); mmd->num_connects++; mmd->active_connections++; /* @@ -384,11 +408,11 @@ static int command_post_select(struct sched *s, void *context) /* parent keeps accepting connections */ return 0; } + peer_name = remote_name(new_fd); + PARA_INFO_LOG("accepted connection from %s\n", peer_name); /* mmd might already have changed at this point */ free(chunk_table); - alarm(ALARM_TIMEOUT); - close_listed_fds(); - signal_shutdown(signal_task); + sct->child_fd = new_fd; /* * put info on who we are serving into argv[0] to make * client ip visible in top/ps @@ -397,21 +421,34 @@ static int command_post_select(struct sched *s, void *context) memset(sct->argv[i], 0, strlen(sct->argv[i])); i = sct->argc - 1 - lls_num_inputs(cmdline_lpr); sprintf(sct->argv[i], "para_server (serving %s)", peer_name); - handle_connect(new_fd, peer_name); - /* never reached*/ + /* ask other tasks to terminate */ + task_notify_all(s, E_CHILD_CONTEXT); + /* + * After we return, the scheduler calls server_select() with a minimal + * timeout value, because the remaining tasks have a notification + * pending. Next it calls the ->post_select method of these tasks, + * which will return negative in view of the notification. This causes + * schedule() to return as there are no more runnable tasks. + * + * Note that semaphores are not inherited across a fork(), so we don't + * hold the lock at this point. Since server_select() drops the lock + * prior to calling para_select(), we need to acquire it here. + */ + mutex_lock(mmd_mutex); + return -E_CHILD_CONTEXT; out: if (ret < 0) PARA_CRIT_LOG("%s\n", para_strerror(-ret)); return 0; } -static void init_server_command_task(int argc, char **argv) +static void init_server_command_task(struct server_command_task *sct, + int argc, char **argv) { int ret; - static struct server_command_task server_command_task_struct, - *sct = &server_command_task_struct; PARA_NOTICE_LOG("initializing tcp command socket\n"); + sct->child_fd = -1; sct->argc = argc; sct->argv = argv; ret = para_listen_simple(IPPROTO_TCP, OPT_UINT32_VAL(PORT)); @@ -437,7 +474,6 @@ err: static int init_afs(int argc, char **argv) { int ret, afs_server_socket[2]; - pid_t afs_pid; char c; ret = socketpair(PF_UNIX, SOCK_STREAM, 0, afs_server_socket); @@ -451,14 +487,14 @@ static int init_afs(int argc, char **argv) if (afs_pid == 0) { /* child (afs) */ int i; + afs_pid = getpid(); for (i = argc - 1; i >= 0; i--) memset(argv[i], 0, strlen(argv[i])); i = argc - lls_num_inputs(cmdline_lpr) - 1; sprintf(argv[i], "para_server (afs)"); close(afs_server_socket[0]); - afs_init(afs_socket_cookie, afs_server_socket[1]); + afs_init(afs_server_socket[1]); } - mmd->afs_pid = afs_pid; close(afs_server_socket[1]); if (read(afs_server_socket[0], &c, 1) <= 0) { PARA_EMERG_LOG("early afs exit\n"); @@ -489,7 +525,7 @@ static void handle_help_flags(void) exit(EXIT_SUCCESS); } -static void server_init(int argc, char **argv) +static void server_init(int argc, char **argv, struct server_command_task *sct) { int ret, afs_socket, daemon_pipe = -1; char *errctx; @@ -509,6 +545,7 @@ static void server_init(int argc, char **argv) /* become daemon */ if (OPT_GIVEN(DAEMON)) daemon_pipe = daemonize(true /* parent waits for SIGTERM */); + server_pid = getpid(); init_random_seed_or_die(); daemon_log_welcome("server"); init_ipc_or_die(); /* init mmd struct and mmd->lock */ @@ -534,8 +571,8 @@ static void server_init(int argc, char **argv) init_signal_task(); para_unblock_signal(SIGCHLD); PARA_NOTICE_LOG("initializing virtual streaming system\n"); - init_vss_task(afs_socket, &sched); - init_server_command_task(argc, argv); + vss_init(afs_socket, &sched); + init_server_command_task(sct, argc, argv); if (daemon_pipe >= 0) { if (write(daemon_pipe, "\0", 1) < 0) { PARA_EMERG_LOG("daemon_pipe: %s", strerror(errno)); @@ -598,18 +635,36 @@ static int server_select(int max_fileno, fd_set *readfds, fd_set *writefds, int main(int argc, char *argv[]) { int ret; + struct server_command_task server_command_task_struct, + *sct = &server_command_task_struct; sched.default_timeout.tv_sec = 1; sched.select_function = server_select; - server_init(argc, argv); + server_init(argc, argv, sct); mutex_lock(mmd_mutex); ret = schedule(&sched); + /* + * We hold the mmd lock: it was re-acquired in server_select() + * after the select call. + */ + mutex_unlock(mmd_mutex); sched_shutdown(&sched); + signal_shutdown(signal_task); + if (!process_is_command_handler()) { /* parent (server) */ + mutex_destroy(mmd_mutex); + shm_detach(mmd); + if (ret < 0) + PARA_EMERG_LOG("%s\n", para_strerror(-ret)); + } else { + alarm(ALARM_TIMEOUT); + close_listed_fds(); + ret = handle_connect(sct->child_fd); + } + vss_shutdown(); + shm_detach(mmd); lls_free_parse_result(server_lpr, CMD_PTR); if (server_lpr != cmdline_lpr) lls_free_parse_result(cmdline_lpr, CMD_PTR); - if (ret < 0) - PARA_EMERG_LOG("%s\n", para_strerror(-ret)); exit(ret < 0? EXIT_FAILURE : EXIT_SUCCESS); }