]> git.decadent.org.uk Git - nfs-utils.git/blobdiff - utils/statd/statd.c
proper merge
[nfs-utils.git] / utils / statd / statd.c
index 4fc135abee256c58484947734f3e8a415aa85787..01fdb41301889bf6f36d6d68d5cc4d6b51673b33 100644 (file)
@@ -7,32 +7,44 @@
  * NSM for Linux.
  */
 
-#include "config.h"
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <sys/stat.h>
 #include <limits.h>
 #include <signal.h>
 #include <unistd.h>
 #include <fcntl.h>
+#include <errno.h>
 #include <string.h>
 #include <getopt.h>
 #include <rpc/rpc.h>
 #include <rpc/pmap_clnt.h>
 #include <rpcmisc.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <grp.h>
+
 #include "statd.h"
-#include "version.h"
+#include "nfslib.h"
+#include "nsm.h"
 
 /* Socket operations */
 #include <sys/types.h>
 #include <sys/socket.h>
 
-
-short int restart = 0;
 int    run_mode = 0;           /* foreground logging mode */
 
 /* LH - I had these local to main, but it seemed silly to have 
  * two copies of each - one in main(), one static in log.c... 
  * It also eliminates the 256-char static in log.c */
-char *name_p = NULL;
-char *version_p = NULL;
+static char *name_p = NULL;
+
+/* PRC: a high-availability callout program can be specified with -H
+ * When this is done, the program will receive callouts whenever clients
+ * are added or deleted to the notify list */
+char *ha_callout_prog = NULL;
 
 static struct option longopts[] =
 {
@@ -43,11 +55,14 @@ static struct option longopts[] =
        { "outgoing-port", 1, 0, 'o' },
        { "port", 1, 0, 'p' },
        { "name", 1, 0, 'n' },
+       { "state-directory-path", 1, 0, 'P' },
+       { "notify-mode", 0, 0, 'N' },
+       { "ha-callout", 1, 0, 'H' },
+       { "no-notify", 0, 0, 'L' },
        { NULL, 0, 0, 0 }
 };
 
 extern void sm_prog_1 (struct svc_req *, register SVCXPRT *);
-extern int statd_get_socket(int port);
 
 #ifdef SIMULATIONS
 extern void simulator (int, char **);
@@ -61,8 +76,7 @@ static void
 sm_prog_1_wrapper (struct svc_req *rqstp, register SVCXPRT *transp)
 {
        /* remote host authorization check */
-       if (!check_default("statd", svc_getcaller(transp),
-                                rqstp->rq_proc, SM_PROG)) {
+       if (!check_default("statd", nfs_getrpccaller(transp), SM_PROG)) {
                svcerr_auth (transp, AUTH_FAILED);
                return;
        }
@@ -73,15 +87,28 @@ sm_prog_1_wrapper (struct svc_req *rqstp, register SVCXPRT *transp)
 #define sm_prog_1 sm_prog_1_wrapper
 #endif
 
+static void
+statd_unregister(void) {
+       nfs_svc_unregister(SM_PROG, SM_VERS);
+}
+
 /*
  * Signal handler.
  */
 static void 
 killer (int sig)
 {
-       log (L_FATAL, "Caught signal %d, un-registering and exiting.", sig);
-       pmap_unset (SM_PROG, SM_VERS);
-       exit (0);
+       statd_unregister ();
+       xlog_err ("Caught signal %d, un-registering and exiting", sig);
+}
+
+static void
+sigusr (int sig)
+{
+       extern void my_svc_exit (void);
+       xlog(D_GENERAL, "Caught signal %d, re-notifying (state %d)", sig,
+                                                               MY_STATE);
+       my_svc_exit();
 }
 
 /*
@@ -100,17 +127,11 @@ static void log_modes(void)
                strcat(buf,"No-Daemon ");
        if (run_mode & MODE_LOG_STDERR)
                strcat(buf,"Log-STDERR ");
-       /* future: IP aliasing
-       if (run_mode & MODE_NOTIFY_ONLY)
-       {
-               strcat(buf,"Notify-Only ");
-       } */
-       log(L_WARNING,buf);
-       /* future: IP aliasing
-       if (run_mode & MODE_NOTIFY_ONLY)
-       {
-               dprintf(L_DEBUG,"Notify IP: %s",svr_addr);
-       } */
+#ifdef HAVE_LIBTIRPC
+       strcat(buf, "TI-RPC ");
+#endif
+
+       xlog_warn(buf);
 }
 
 /*
@@ -118,7 +139,7 @@ static void log_modes(void)
  * help the occasional admin. 
  */
 static void 
-usage()
+usage(void)
 {
        fprintf(stderr,"usage: %s [options]\n", name_p);
        fprintf(stderr,"      -h, -?, --help       Print this help screen.\n");
@@ -128,8 +149,64 @@ usage()
        fprintf(stderr,"      -o, --outgoing-port  Port for outgoing connections\n");
        fprintf(stderr,"      -V, -v, --version    Display version information and exit.\n");
        fprintf(stderr,"      -n, --name           Specify a local hostname.\n");
+       fprintf(stderr,"      -P                   State directory path.\n");
+       fprintf(stderr,"      -N                   Run in notify only mode.\n");
+       fprintf(stderr,"      -L, --no-notify      Do not perform any notification.\n");
+       fprintf(stderr,"      -H                   Specify a high-availability callout program.\n");
 }
 
+static const char *pidfile = "/var/run/rpc.statd.pid";
+
+int pidfd = -1;
+static void create_pidfile(void)
+{
+       FILE *fp;
+
+       unlink(pidfile);
+       fp = fopen(pidfile, "w");
+       if (!fp)
+               xlog_err("Opening %s failed: %m\n", pidfile);
+       fprintf(fp, "%d\n", getpid());
+       pidfd = dup(fileno(fp));
+       if (fclose(fp) < 0) {
+               xlog_warn("Flushing pid file failed: errno %d (%m)\n",
+                       errno);
+       }
+}
+
+static void truncate_pidfile(void)
+{
+       if (pidfd >= 0) {
+               if (ftruncate(pidfd, 0) < 0) {
+                       xlog_warn("truncating pid file failed: errno %d (%m)\n",
+                               errno);
+               }
+       }
+}
+
+static void run_sm_notify(int outport)
+{
+       char op[20];
+       char *av[6];
+       int ac = 0;
+
+       av[ac++] = "/usr/sbin/sm-notify";
+       if (run_mode & MODE_NODAEMON)
+               av[ac++] = "-d";
+       if (outport) {
+               sprintf(op, "-p%d", outport);
+               av[ac++] = op;
+       }
+       if (run_mode & STATIC_HOSTNAME) {
+               av[ac++] = "-v";
+               av[ac++] = MY_NAME;
+       }
+       av[ac] = NULL;
+       execv(av[0], av);
+       fprintf(stderr, "%s: failed to run %s\n", name_p, av[0]);
+       exit(2);
+
+}
 /* 
  * Entry routine/main loop.
  */
@@ -139,9 +216,15 @@ int main (int argc, char **argv)
        int pid;
        int arg;
        int port = 0, out_port = 0;
+       struct rlimit rlim;
+
+       int pipefds[2] = { -1, -1};
+       char status;
 
        /* Default: daemon mode, no other options */
        run_mode = 0;
+       xlog_stderr(0);
+       xlog_syslog(1);
 
        /* Set the basename */
        if ((name_p = strrchr(argv[0],'/')) != NULL) {
@@ -150,26 +233,25 @@ int main (int argc, char **argv)
                name_p = argv[0];
        }
 
-       /* Get the version */
-       if ((version_p = strrchr(VERSION,' ')) != NULL) {
-               version_p++;
-       } else {
-               version_p = VERSION;
-       }
-       
        /* Set hostname */
        MY_NAME = NULL;
 
        /* Process command line switches */
-       while ((arg = getopt_long(argc, argv, "h?vVFdn:p:o:", longopts, NULL)) != EOF) {
+       while ((arg = getopt_long(argc, argv, "h?vVFNH:dn:p:o:P:L", longopts, NULL)) != EOF) {
                switch (arg) {
                case 'V':       /* Version */
                case 'v':
-                       printf("%s version %s\n",name_p,version_p);
+                       printf("%s version " VERSION "\n",name_p);
                        exit(0);
                case 'F':       /* Foreground/nodaemon mode */
                        run_mode |= MODE_NODAEMON;
                        break;
+               case 'N':
+                       run_mode |= MODE_NOTIFY_ONLY;
+                       break;
+               case 'L': /* Listen only */
+                       run_mode |= MODE_NO_NOTIFY;
+                       break;
                case 'd':       /* No daemon only - log to stderr */
                        run_mode |= MODE_LOG_STDERR;
                        break;
@@ -192,8 +274,20 @@ int main (int argc, char **argv)
                        }
                        break;
                case 'n':       /* Specify local hostname */
+                       run_mode |= STATIC_HOSTNAME;
                        MY_NAME = xstrdup(optarg);
                        break;
+               case 'P':
+                       if (!nsm_setup_pathnames(argv[0], optarg))
+                               exit(1);
+                       break;
+               case 'H': /* PRC: specify the ha-callout program */
+                       if ((ha_callout_prog = xstrdup(optarg)) == NULL) {
+                               fprintf(stderr, "%s: xstrdup(%s) failed!\n",
+                                       argv[0], optarg);
+                               exit(1);
+                       }
+                       break;
                case '?':       /* heeeeeelllllllpppp? heh */
                case 'h':
                        usage();
@@ -209,14 +303,31 @@ int main (int argc, char **argv)
                exit(-1);
        }
 
+       if (run_mode & MODE_NOTIFY_ONLY) {
+               fprintf(stderr, "%s: -N deprecated, consider using /usr/sbin/sm-notify directly\n",
+                       name_p);
+               run_sm_notify(out_port);
+       }
+
        if (!(run_mode & MODE_NODAEMON)) {
                run_mode &= ~MODE_LOG_STDERR;   /* Never log to console in
                                                   daemon mode. */
        }
 
-       log_init (name_p,version_p);
-
-       log_modes();
+       if (getrlimit (RLIMIT_NOFILE, &rlim) != 0)
+               fprintf(stderr, "%s: getrlimit (RLIMIT_NOFILE) failed: %s\n",
+                               argv [0], strerror(errno));
+       else {
+               /* glibc sunrpc code dies if getdtablesize > FD_SETSIZE */
+               if (rlim.rlim_cur > FD_SETSIZE) {
+                       rlim.rlim_cur = FD_SETSIZE;
+
+                       if (setrlimit (RLIMIT_NOFILE, &rlim) != 0) {
+                               fprintf(stderr, "%s: setrlimit (RLIMIT_NOFILE) failed: %s\n",
+                                       argv [0], strerror(errno));
+                       }
+               }
+       }
 
 #ifdef SIMULATIONS
        if (argc > 1)
@@ -225,58 +336,158 @@ int main (int argc, char **argv)
 #endif
        
        if (!(run_mode & MODE_NODAEMON)) {
-               int filedes, fdmax, tempfd;
+               int tempfd;
 
+               if (pipe(pipefds)<0) {
+                       perror("statd: unable to create pipe");
+                       exit(1);
+               }
                if ((pid = fork ()) < 0) {
-                       perror ("Could not fork");
+                       perror ("statd: Could not fork");
                        exit (1);
                } else if (pid != 0) {
-                       /* Parent. */
+                       /* Parent.
+                        * Wait for status from child.
+                        */
+                       close(pipefds[1]);
+                       if (read(pipefds[0], &status, 1) != 1)
+                               exit(1);
                        exit (0);
                }
                /* Child.       */
+               close(pipefds[0]);
                setsid ();
-               chdir (DIR_BASE);
 
-               tempfd = open("/dev/null", O_RDWR);
-               close(0); dup2(tempfd, 0);
-               close(1); dup2(tempfd, 1);
-               close(2); dup2(tempfd, 2);
-               fdmax = sysconf (_SC_OPEN_MAX);
-               for (filedes = 3; filedes < fdmax; filedes++) {
-                       close (filedes);
+               while (pipefds[1] <= 2) {
+                       pipefds[1] = dup(pipefds[1]);
+                       if (pipefds[1]<0) {
+                               perror("statd: dup");
+                               exit(1);
+                       }
                }
+               tempfd = open("/dev/null", O_RDWR);
+               dup2(tempfd, 0);
+               dup2(tempfd, 1);
+               dup2(tempfd, 2);
+               dup2(pipefds[1], 3);
+               pipefds[1] = 3;
+               closeall(4);
        }
 
        /* Child. */
+
+       if (run_mode & MODE_LOG_STDERR) {
+               xlog_syslog(0);
+               xlog_stderr(1);
+               xlog_config(D_ALL, 1);
+       }
+       xlog_open(name_p);
+       xlog(L_NOTICE, "Version " VERSION " starting");
+
+       log_modes();
+
        signal (SIGHUP, killer);
        signal (SIGINT, killer);
        signal (SIGTERM, killer);
+       /* PRC: trap SIGUSR1 to re-read notify list from disk */
+       signal(SIGUSR1, sigusr);
        /* WARNING: the following works on Linux and SysV, but not BSD! */
        signal(SIGCHLD, SIG_IGN);
+       /*
+        * Ignore SIGPIPE to avoid statd dying when peers close their
+        * TCP connection while we're trying to reply to them.
+        */
+       signal(SIGPIPE, SIG_IGN);
+
+       create_pidfile();
+       atexit(truncate_pidfile);
+
+       if (! (run_mode & MODE_NO_NOTIFY))
+               switch (pid = fork()) {
+               case 0:
+                       run_sm_notify(out_port);
+                       break;
+               case -1:
+                       break;
+               default:
+                       waitpid(pid, NULL, 0);
+               }
 
-       /* initialize out_port */
-       statd_get_socket(out_port);
+       /* Make sure we have a privilege port for calling into the kernel */
+       if (statd_get_socket() < 0)
+               exit(1);
+
+       /* If sm-notify didn't take all the state files, load
+        * state information into our notify-list so we can
+        * pass on any SM_NOTIFY that arrives
+        */
+       load_state();
+
+       MY_STATE = nsm_get_state(0);
+       if (MY_STATE == 0)
+               exit(1);
+       xlog(D_GENERAL, "Local NSM state number: %d", MY_STATE);
+       nsm_update_kernel_state(MY_STATE);
+
+       /*
+        * ORDER
+        * Clear old listeners while still root, to override any
+        * permission checking done by rpcbind.
+        */
+       statd_unregister();
+
+       /*
+        * ORDER
+        */
+       if (!nsm_drop_privileges(pidfd))
+               exit(1);
+
+       /*
+        * ORDER
+        * Create RPC listeners after dropping privileges.  This permits
+        * statd to unregister its own listeners when it exits.
+        */
+       if (nfs_svc_create("statd", SM_PROG, SM_VERS, sm_prog_1, port) == 0) {
+               xlog(L_ERROR, "failed to create RPC listeners, exiting");
+               exit(1);
+       }
+       atexit(statd_unregister);
+
+       /* If we got this far, we have successfully started, so notify parent */
+       if (pipefds[1] > 0) {
+               status = 0;
+               if (write(pipefds[1], &status, 1) != 1) {
+                       xlog_warn("writing to parent pipe failed: errno %d (%s)\n",
+                               errno, strerror(errno));
+               }
+               close(pipefds[1]);
+               pipefds[1] = -1;
+       }
 
        for (;;) {
-               pmap_unset (SM_PROG, SM_VERS);
-               change_state ();
-               shuffle_dirs ();        /* Move directory names around */
-               notify_hosts ();        /* Send out notify requests */
-               ++restart;
-
-               /* future: IP aliasing 
-               if (!(run_mode & MODE_NOTIFY_ONLY)) {
-                       rpc_init("statd", SM_PROG, SM_VERS, sm_prog_1, port);
-               } */
-               /* this registers both UDP and TCP services */
-               rpc_init("statd", SM_PROG, SM_VERS, sm_prog_1, port);
-
                /*
                 * Handle incoming requests:  SM_NOTIFY socket requests, as
                 * well as callbacks from lockd.
                 */
                my_svc_run();   /* I rolled my own, Olaf made it better... */
+
+               /* Only get here when simulating a crash so we should probably
+                * start sm-notify running again.  As we have already dropped
+                * privileges, this might not work, but I don't think
+                * responding to SM_SIMU_CRASH is an important use cases to
+                * get perfect.
+                */
+               if (! (run_mode & MODE_NO_NOTIFY))
+                       switch (pid = fork()) {
+                       case 0:
+                               run_sm_notify(out_port);
+                               break;
+                       case -1:
+                               break;
+                       default:
+                               waitpid(pid, NULL, 0);
+                       }
+
        }
        return 0;
 }