cmd/zed/zed.c

   1 /*
   2  * This file is part of the ZFS Event Daemon (ZED).
   3  *
   4  * Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
   5  * Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
   6  * Refer to the OpenZFS git commit log for authoritative copyright attribution.
   7  *
   8  * The contents of this file are subject to the terms of the
   9  * Common Development and Distribution License Version 1.0 (CDDL-1.0).
  10  * You can obtain a copy of the license from the top-level file
  11  * "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
  12  * You may not use this file except in compliance with the license.
  13  */
  14
  15 #include <errno.h>
  16 #include <fcntl.h>
  17 #include <signal.h>
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <sys/mman.h>
  22 #include <sys/stat.h>
  23 #include <unistd.h>
  24 #include "zed.h"
  25 #include "zed_conf.h"
  26 #include "zed_event.h"
  27 #include "zed_file.h"
  28 #include "zed_log.h"
  29
  30 static volatile sig_atomic_t _got_exit = 0;
  31 static volatile sig_atomic_t _got_hup = 0;
  32
  33 /*
  34  * Signal handler for SIGINT & SIGTERM.
  35  */
  36 static void
  37 _exit_handler(int signum)
  38 {
  39         (void) signum;
  40         _got_exit = 1;
  41 }
  42
  43 /*
  44  * Signal handler for SIGHUP.
  45  */
  46 static void
  47 _hup_handler(int signum)
  48 {
  49         (void) signum;
  50         _got_hup = 1;
  51 }
  52
  53 /*
  54  * Register signal handlers.
  55  */
  56 static void
  57 _setup_sig_handlers(void)
  58 {
  59         struct sigaction sa;
  60
  61         if (sigemptyset(&sa.sa_mask) < 0)
  62                 zed_log_die("Failed to initialize sigset");
  63
  64         sa.sa_flags = SA_RESTART;
  65
  66         sa.sa_handler = SIG_IGN;
  67         if (sigaction(SIGPIPE, &sa, NULL) < 0)
  68                 zed_log_die("Failed to ignore SIGPIPE");
  69
  70         sa.sa_handler = _exit_handler;
  71         if (sigaction(SIGINT, &sa, NULL) < 0)
  72                 zed_log_die("Failed to register SIGINT handler");
  73
  74         if (sigaction(SIGTERM, &sa, NULL) < 0)
  75                 zed_log_die("Failed to register SIGTERM handler");
  76
  77         sa.sa_handler = _hup_handler;
  78         if (sigaction(SIGHUP, &sa, NULL) < 0)
  79                 zed_log_die("Failed to register SIGHUP handler");
  80
  81         (void) sigaddset(&sa.sa_mask, SIGCHLD);
  82         if (pthread_sigmask(SIG_BLOCK, &sa.sa_mask, NULL) < 0)
  83                 zed_log_die("Failed to block SIGCHLD");
  84 }
  85
  86 /*
  87  * Lock all current and future pages in the virtual memory address space.
  88  * Access to locked pages will never be delayed by a page fault.
  89  *
  90  * EAGAIN is tested up to max_tries in case this is a transient error.
  91  *
  92  * Note that memory locks are not inherited by a child created via fork()
  93  * and are automatically removed during an execve().  As such, this must
  94  * be called after the daemon fork()s (when running in the background).
  95  */
  96 static void
  97 _lock_memory(void)
  98 {
  99 #if HAVE_MLOCKALL
 100         int i = 0;
 101         const int max_tries = 10;
 102
 103         for (i = 0; i < max_tries; i++) {
 104                 if (mlockall(MCL_CURRENT | MCL_FUTURE) == 0) {
 105                         zed_log_msg(LOG_INFO, "Locked all pages in memory");
 106                         return;
 107                 }
 108                 if (errno != EAGAIN)
 109                         break;
 110         }
 111         zed_log_die("Failed to lock memory pages: %s", strerror(errno));
 112
 113 #else /* HAVE_MLOCKALL */
 114         zed_log_die("Failed to lock memory pages: mlockall() not supported");
 115 #endif /* HAVE_MLOCKALL */
 116 }
 117
 118 /*
 119  * Start daemonization of the process including the double fork().
 120  *
 121  * The parent process will block here until _finish_daemonize() is called
 122  * (in the grandchild process), at which point the parent process will exit.
 123  * This prevents the parent process from exiting until initialization is
 124  * complete.
 125  */
 126 static void
 127 _start_daemonize(void)
 128 {
 129         pid_t pid;
 130         struct sigaction sa;
 131
 132         /* Create pipe for communicating with child during daemonization. */
 133         zed_log_pipe_open();
 134
 135         /* Background process and ensure child is not process group leader. */
 136         pid = fork();
 137         if (pid < 0) {
 138                 zed_log_die("Failed to create child process: %s",
 139                     strerror(errno));
 140         } else if (pid > 0) {
 141
 142                 /* Close writes since parent will only read from pipe. */
 143                 zed_log_pipe_close_writes();
 144
 145                 /* Wait for notification that daemonization is complete. */
 146                 zed_log_pipe_wait();
 147
 148                 zed_log_pipe_close_reads();
 149                 _exit(EXIT_SUCCESS);
 150         }
 151
 152         /* Close reads since child will only write to pipe. */
 153         zed_log_pipe_close_reads();
 154
 155         /* Create independent session and detach from terminal. */
 156         if (setsid() < 0)
 157                 zed_log_die("Failed to create new session: %s",
 158                     strerror(errno));
 159
 160         /* Prevent child from terminating on HUP when session leader exits. */
 161         if (sigemptyset(&sa.sa_mask) < 0)
 162                 zed_log_die("Failed to initialize sigset");
 163
 164         sa.sa_flags = 0;
 165         sa.sa_handler = SIG_IGN;
 166
 167         if (sigaction(SIGHUP, &sa, NULL) < 0)
 168                 zed_log_die("Failed to ignore SIGHUP");
 169
 170         /* Ensure process cannot re-acquire terminal. */
 171         pid = fork();
 172         if (pid < 0) {
 173                 zed_log_die("Failed to create grandchild process: %s",
 174                     strerror(errno));
 175         } else if (pid > 0) {
 176                 _exit(EXIT_SUCCESS);
 177         }
 178 }
 179
 180 /*
 181  * Finish daemonization of the process by closing stdin/stdout/stderr.
 182  *
 183  * This must be called at the end of initialization after all external
 184  * communication channels are established and accessible.
 185  */
 186 static void
 187 _finish_daemonize(void)
 188 {
 189         int devnull;
 190
 191         /* Preserve fd 0/1/2, but discard data to/from stdin/stdout/stderr. */
 192         devnull = open("/dev/null", O_RDWR);
 193         if (devnull < 0)
 194                 zed_log_die("Failed to open /dev/null: %s", strerror(errno));
 195
 196         if (dup2(devnull, STDIN_FILENO) < 0)
 197                 zed_log_die("Failed to dup /dev/null onto stdin: %s",
 198                     strerror(errno));
 199
 200         if (dup2(devnull, STDOUT_FILENO) < 0)
 201                 zed_log_die("Failed to dup /dev/null onto stdout: %s",
 202                     strerror(errno));
 203
 204         if (dup2(devnull, STDERR_FILENO) < 0)
 205                 zed_log_die("Failed to dup /dev/null onto stderr: %s",
 206                     strerror(errno));
 207
 208         if ((devnull > STDERR_FILENO) && (close(devnull) < 0))
 209                 zed_log_die("Failed to close /dev/null: %s", strerror(errno));
 210
 211         /* Notify parent that daemonization is complete. */
 212         zed_log_pipe_close_writes();
 213 }
 214
 215 /*
 216  * ZFS Event Daemon (ZED).
 217  */
 218 int
 219 main(int argc, char *argv[])
 220 {
 221         struct zed_conf zcp;
 222         uint64_t saved_eid;
 223         int64_t saved_etime[2];
 224
 225         zed_log_init(argv[0]);
 226         zed_log_stderr_open(LOG_NOTICE);
 227         zed_conf_init(&zcp);
 228         zed_conf_parse_opts(&zcp, argc, argv);
 229         if (zcp.do_verbose)
 230                 zed_log_stderr_open(LOG_INFO);
 231
 232         if (geteuid() != 0)
 233                 zed_log_die("Must be run as root");
 234
 235         zed_file_close_from(STDERR_FILENO + 1);
 236
 237         (void) umask(0);
 238
 239         if (chdir("/") < 0)
 240                 zed_log_die("Failed to change to root directory");
 241
 242         if (zed_conf_scan_dir(&zcp) < 0)
 243                 exit(EXIT_FAILURE);
 244
 245         if (!zcp.do_foreground) {
 246                 _start_daemonize();
 247                 zed_log_syslog_open(LOG_DAEMON);
 248         }
 249         _setup_sig_handlers();
 250
 251         if (zcp.do_memlock)
 252                 _lock_memory();
 253
 254         if ((zed_conf_write_pid(&zcp) < 0) && (!zcp.do_force))
 255                 exit(EXIT_FAILURE);
 256
 257         if (!zcp.do_foreground)
 258                 _finish_daemonize();
 259
 260         zed_log_msg(LOG_NOTICE,
 261             "ZFS Event Daemon %s-%s (PID %d)",
 262             ZFS_META_VERSION, ZFS_META_RELEASE, (int)getpid());
 263
 264         if (zed_conf_open_state(&zcp) < 0)
 265                 exit(EXIT_FAILURE);
 266
 267         if (zed_conf_read_state(&zcp, &saved_eid, saved_etime) < 0)
 268                 exit(EXIT_FAILURE);
 269
 270 idle:
 271         /*
 272          * If -I is specified, attempt to open /dev/zfs repeatedly until
 273          * successful.
 274          */
 275         do {
 276                 if (!zed_event_init(&zcp))
 277                         break;
 278                 /* Wait for some time and try again. tunable? */
 279                 sleep(30);
 280         } while (!_got_exit && zcp.do_idle);
 281
 282         if (_got_exit)
 283                 goto out;
 284
 285         zed_event_seek(&zcp, saved_eid, saved_etime);
 286
 287         while (!_got_exit) {
 288                 int rv;
 289                 if (_got_hup) {
 290                         _got_hup = 0;
 291                         (void) zed_conf_scan_dir(&zcp);
 292                 }
 293                 rv = zed_event_service(&zcp);
 294
 295                 /* ENODEV: When kernel module is unloaded (osx) */
 296                 if (rv != 0)
 297                         break;
 298         }
 299
 300         zed_log_msg(LOG_NOTICE, "Exiting");
 301         zed_event_fini(&zcp);
 302
 303         if (zcp.do_idle && !_got_exit)
 304                 goto idle;
 305
 306 out:
 307         zed_conf_destroy(&zcp);
 308         zed_log_fini();
 309         exit(EXIT_SUCCESS);
 310 }