1 /* 2 * This file is part of the ZFS Event Daemon (ZED) 3 * for ZFS on Linux (ZoL) <http://zfsonlinux.org/>. 4 * Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049). 5 * Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC. 6 * Refer to the ZoL 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 <assert.h> 16 #include <ctype.h> 17 #include <dirent.h> 18 #include <errno.h> 19 #include <fcntl.h> 20 #include <libgen.h> 21 #include <limits.h> 22 #include <stdio.h> 23 #include <stdlib.h> 24 #include <string.h> 25 #include <sys/stat.h> 26 #include <sys/uio.h> 27 #include <unistd.h> 28 #include "zed.h" 29 #include "zed_conf.h" 30 #include "zed_file.h" 31 #include "zed_log.h" 32 #include "zed_strings.h" 33 34 /* 35 * Return a new configuration with default values. 36 */ 37 struct zed_conf * 38 zed_conf_create(void) 39 { 40 struct zed_conf *zcp; 41 42 zcp = calloc(1, sizeof (*zcp)); 43 if (!zcp) 44 goto nomem; 45 46 zcp->syslog_facility = LOG_DAEMON; 47 zcp->min_events = ZED_MIN_EVENTS; 48 zcp->max_events = ZED_MAX_EVENTS; 49 zcp->pid_fd = -1; 50 zcp->zedlets = NULL; /* created via zed_conf_scan_dir() */ 51 zcp->state_fd = -1; /* opened via zed_conf_open_state() */ 52 zcp->zfs_hdl = NULL; /* opened via zed_event_init() */ 53 zcp->zevent_fd = -1; /* opened via zed_event_init() */ 54 55 if (!(zcp->conf_file = strdup(ZED_CONF_FILE))) 56 goto nomem; 57 58 if (!(zcp->pid_file = strdup(ZED_PID_FILE))) 59 goto nomem; 60 61 if (!(zcp->zedlet_dir = strdup(ZED_ZEDLET_DIR))) 62 goto nomem; 63 64 if (!(zcp->state_file = strdup(ZED_STATE_FILE))) 65 goto nomem; 66 67 return (zcp); 68 69 nomem: 70 zed_log_die("Failed to create conf: %s", strerror(errno)); 71 return (NULL); 72 } 73 74 /* 75 * Destroy the configuration [zcp]. 76 * 77 * Note: zfs_hdl & zevent_fd are destroyed via zed_event_fini(). 78 */ 79 void 80 zed_conf_destroy(struct zed_conf *zcp) 81 { 82 if (!zcp) 83 return; 84 85 if (zcp->state_fd >= 0) { 86 if (close(zcp->state_fd) < 0) 87 zed_log_msg(LOG_WARNING, 88 "Failed to close state file \"%s\": %s", 89 zcp->state_file, strerror(errno)); 90 zcp->state_fd = -1; 91 } 92 if (zcp->pid_file) { 93 if ((unlink(zcp->pid_file) < 0) && (errno != ENOENT)) 94 zed_log_msg(LOG_WARNING, 95 "Failed to remove PID file \"%s\": %s", 96 zcp->pid_file, strerror(errno)); 97 } 98 if (zcp->pid_fd >= 0) { 99 if (close(zcp->pid_fd) < 0) 100 zed_log_msg(LOG_WARNING, 101 "Failed to close PID file \"%s\": %s", 102 zcp->pid_file, strerror(errno)); 103 zcp->pid_fd = -1; 104 } 105 if (zcp->conf_file) { 106 free(zcp->conf_file); 107 zcp->conf_file = NULL; 108 } 109 if (zcp->pid_file) { 110 free(zcp->pid_file); 111 zcp->pid_file = NULL; 112 } 113 if (zcp->zedlet_dir) { 114 free(zcp->zedlet_dir); 115 zcp->zedlet_dir = NULL; 116 } 117 if (zcp->state_file) { 118 free(zcp->state_file); 119 zcp->state_file = NULL; 120 } 121 if (zcp->zedlets) { 122 zed_strings_destroy(zcp->zedlets); 123 zcp->zedlets = NULL; 124 } 125 free(zcp); 126 } 127 128 /* 129 * Display command-line help and exit. 130 * 131 * If [got_err] is 0, output to stdout and exit normally; 132 * otherwise, output to stderr and exit with a failure status. 133 */ 134 static void 135 _zed_conf_display_help(const char *prog, int got_err) 136 { 137 FILE *fp = got_err ? stderr : stdout; 138 int w1 = 4; /* width of leading whitespace */ 139 int w2 = 8; /* width of L-justified option field */ 140 141 fprintf(fp, "Usage: %s [OPTION]...\n", (prog ? prog : "zed")); 142 fprintf(fp, "\n"); 143 fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-h", 144 "Display help."); 145 fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-L", 146 "Display license information."); 147 fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-V", 148 "Display version information."); 149 fprintf(fp, "\n"); 150 fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-v", 151 "Be verbose."); 152 fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-f", 153 "Force daemon to run."); 154 fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-F", 155 "Run daemon in the foreground."); 156 fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-I", 157 "Idle daemon until kernel module is (re)loaded."); 158 fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-M", 159 "Lock all pages in memory."); 160 fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-P", 161 "$PATH for ZED to use (only used by ZTS)."); 162 fprintf(fp, "%*c%*s %s\n", w1, 0x20, -w2, "-Z", 163 "Zero state file."); 164 fprintf(fp, "\n"); 165 #if 0 166 fprintf(fp, "%*c%*s %s [%s]\n", w1, 0x20, -w2, "-c FILE", 167 "Read configuration from FILE.", ZED_CONF_FILE); 168 #endif 169 fprintf(fp, "%*c%*s %s [%s]\n", w1, 0x20, -w2, "-d DIR", 170 "Read enabled ZEDLETs from DIR.", ZED_ZEDLET_DIR); 171 fprintf(fp, "%*c%*s %s [%s]\n", w1, 0x20, -w2, "-p FILE", 172 "Write daemon's PID to FILE.", ZED_PID_FILE); 173 fprintf(fp, "%*c%*s %s [%s]\n", w1, 0x20, -w2, "-s FILE", 174 "Write daemon's state to FILE.", ZED_STATE_FILE); 175 fprintf(fp, "\n"); 176 177 exit(got_err ? EXIT_FAILURE : EXIT_SUCCESS); 178 } 179 180 /* 181 * Display license information to stdout and exit. 182 */ 183 static void 184 _zed_conf_display_license(void) 185 { 186 const char **pp; 187 const char *text[] = { 188 "The ZFS Event Daemon (ZED) is distributed under the terms of the", 189 " Common Development and Distribution License (CDDL-1.0)", 190 " <http://opensource.org/licenses/CDDL-1.0>.", 191 "", 192 "Developed at Lawrence Livermore National Laboratory" 193 " (LLNL-CODE-403049).", 194 "", 195 NULL 196 }; 197 198 for (pp = text; *pp; pp++) 199 printf("%s\n", *pp); 200 201 exit(EXIT_SUCCESS); 202 } 203 204 /* 205 * Display version information to stdout and exit. 206 */ 207 static void 208 _zed_conf_display_version(void) 209 { 210 printf("%s-%s-%s\n", 211 ZFS_META_NAME, ZFS_META_VERSION, ZFS_META_RELEASE); 212 213 exit(EXIT_SUCCESS); 214 } 215 216 /* 217 * Copy the [path] string to the [resultp] ptr. 218 * If [path] is not an absolute path, prefix it with the current working dir. 219 * If [resultp] is non-null, free its existing string before assignment. 220 */ 221 static void 222 _zed_conf_parse_path(char **resultp, const char *path) 223 { 224 char buf[PATH_MAX]; 225 226 assert(resultp != NULL); 227 assert(path != NULL); 228 229 if (*resultp) 230 free(*resultp); 231 232 if (path[0] == '/') { 233 *resultp = strdup(path); 234 } else if (!getcwd(buf, sizeof (buf))) { 235 zed_log_die("Failed to get current working dir: %s", 236 strerror(errno)); 237 } else if (strlcat(buf, "/", sizeof (buf)) >= sizeof (buf)) { 238 zed_log_die("Failed to copy path: %s", strerror(ENAMETOOLONG)); 239 } else if (strlcat(buf, path, sizeof (buf)) >= sizeof (buf)) { 240 zed_log_die("Failed to copy path: %s", strerror(ENAMETOOLONG)); 241 } else { 242 *resultp = strdup(buf); 243 } 244 if (!*resultp) 245 zed_log_die("Failed to copy path: %s", strerror(ENOMEM)); 246 } 247 248 /* 249 * Parse the command-line options into the configuration [zcp]. 250 */ 251 void 252 zed_conf_parse_opts(struct zed_conf *zcp, int argc, char **argv) 253 { 254 const char * const opts = ":hLVc:d:p:P:s:vfFMZI"; 255 int opt; 256 257 if (!zcp || !argv || !argv[0]) 258 zed_log_die("Failed to parse options: Internal error"); 259 260 opterr = 0; /* suppress default getopt err msgs */ 261 262 while ((opt = getopt(argc, argv, opts)) != -1) { 263 switch (opt) { 264 case 'h': 265 _zed_conf_display_help(argv[0], EXIT_SUCCESS); 266 break; 267 case 'L': 268 _zed_conf_display_license(); 269 break; 270 case 'V': 271 _zed_conf_display_version(); 272 break; 273 case 'c': 274 _zed_conf_parse_path(&zcp->conf_file, optarg); 275 break; 276 case 'd': 277 _zed_conf_parse_path(&zcp->zedlet_dir, optarg); 278 break; 279 case 'I': 280 zcp->do_idle = 1; 281 break; 282 case 'p': 283 _zed_conf_parse_path(&zcp->pid_file, optarg); 284 break; 285 case 'P': 286 _zed_conf_parse_path(&zcp->path, optarg); 287 break; 288 case 's': 289 _zed_conf_parse_path(&zcp->state_file, optarg); 290 break; 291 case 'v': 292 zcp->do_verbose = 1; 293 break; 294 case 'f': 295 zcp->do_force = 1; 296 break; 297 case 'F': 298 zcp->do_foreground = 1; 299 break; 300 case 'M': 301 zcp->do_memlock = 1; 302 break; 303 case 'Z': 304 zcp->do_zero = 1; 305 break; 306 case '?': 307 default: 308 if (optopt == '?') 309 _zed_conf_display_help(argv[0], EXIT_SUCCESS); 310 311 fprintf(stderr, "%s: %s '-%c'\n\n", argv[0], 312 "Invalid option", optopt); 313 _zed_conf_display_help(argv[0], EXIT_FAILURE); 314 break; 315 } 316 } 317 } 318 319 /* 320 * Parse the configuration file into the configuration [zcp]. 321 * 322 * FIXME: Not yet implemented. 323 */ 324 void 325 zed_conf_parse_file(struct zed_conf *zcp) 326 { 327 if (!zcp) 328 zed_log_die("Failed to parse config: %s", strerror(EINVAL)); 329 } 330 331 /* 332 * Scan the [zcp] zedlet_dir for files to exec based on the event class. 333 * Files must be executable by user, but not writable by group or other. 334 * Dotfiles are ignored. 335 * 336 * Return 0 on success with an updated set of zedlets, 337 * or -1 on error with errno set. 338 * 339 * FIXME: Check if zedlet_dir and all parent dirs are secure. 340 */ 341 int 342 zed_conf_scan_dir(struct zed_conf *zcp) 343 { 344 zed_strings_t *zedlets; 345 DIR *dirp; 346 struct dirent *direntp; 347 char pathname[PATH_MAX]; 348 struct stat st; 349 int n; 350 351 if (!zcp) { 352 errno = EINVAL; 353 zed_log_msg(LOG_ERR, "Failed to scan zedlet dir: %s", 354 strerror(errno)); 355 return (-1); 356 } 357 zedlets = zed_strings_create(); 358 if (!zedlets) { 359 errno = ENOMEM; 360 zed_log_msg(LOG_WARNING, "Failed to scan dir \"%s\": %s", 361 zcp->zedlet_dir, strerror(errno)); 362 return (-1); 363 } 364 dirp = opendir(zcp->zedlet_dir); 365 if (!dirp) { 366 int errno_bak = errno; 367 zed_log_msg(LOG_WARNING, "Failed to open dir \"%s\": %s", 368 zcp->zedlet_dir, strerror(errno)); 369 zed_strings_destroy(zedlets); 370 errno = errno_bak; 371 return (-1); 372 } 373 while ((direntp = readdir(dirp))) { 374 if (direntp->d_name[0] == '.') 375 continue; 376 377 n = snprintf(pathname, sizeof (pathname), 378 "%s/%s", zcp->zedlet_dir, direntp->d_name); 379 if ((n < 0) || (n >= sizeof (pathname))) { 380 zed_log_msg(LOG_WARNING, "Failed to stat \"%s\": %s", 381 direntp->d_name, strerror(ENAMETOOLONG)); 382 continue; 383 } 384 if (stat(pathname, &st) < 0) { 385 zed_log_msg(LOG_WARNING, "Failed to stat \"%s\": %s", 386 pathname, strerror(errno)); 387 continue; 388 } 389 if (!S_ISREG(st.st_mode)) { 390 zed_log_msg(LOG_INFO, 391 "Ignoring \"%s\": not a regular file", 392 direntp->d_name); 393 continue; 394 } 395 if ((st.st_uid != 0) && !zcp->do_force) { 396 zed_log_msg(LOG_NOTICE, 397 "Ignoring \"%s\": not owned by root", 398 direntp->d_name); 399 continue; 400 } 401 if (!(st.st_mode & S_IXUSR)) { 402 zed_log_msg(LOG_INFO, 403 "Ignoring \"%s\": not executable by user", 404 direntp->d_name); 405 continue; 406 } 407 if ((st.st_mode & S_IWGRP) && !zcp->do_force) { 408 zed_log_msg(LOG_NOTICE, 409 "Ignoring \"%s\": writable by group", 410 direntp->d_name); 411 continue; 412 } 413 if ((st.st_mode & S_IWOTH) && !zcp->do_force) { 414 zed_log_msg(LOG_NOTICE, 415 "Ignoring \"%s\": writable by other", 416 direntp->d_name); 417 continue; 418 } 419 if (zed_strings_add(zedlets, NULL, direntp->d_name) < 0) { 420 zed_log_msg(LOG_WARNING, 421 "Failed to register \"%s\": %s", 422 direntp->d_name, strerror(errno)); 423 continue; 424 } 425 if (zcp->do_verbose) 426 zed_log_msg(LOG_INFO, 427 "Registered zedlet \"%s\"", direntp->d_name); 428 } 429 if (closedir(dirp) < 0) { 430 int errno_bak = errno; 431 zed_log_msg(LOG_WARNING, "Failed to close dir \"%s\": %s", 432 zcp->zedlet_dir, strerror(errno)); 433 zed_strings_destroy(zedlets); 434 errno = errno_bak; 435 return (-1); 436 } 437 if (zcp->zedlets) 438 zed_strings_destroy(zcp->zedlets); 439 440 zcp->zedlets = zedlets; 441 return (0); 442 } 443 444 /* 445 * Write the PID file specified in [zcp]. 446 * Return 0 on success, -1 on error. 447 * 448 * This must be called after fork()ing to become a daemon (so the correct PID 449 * is recorded), but before daemonization is complete and the parent process 450 * exits (for synchronization with systemd). 451 */ 452 int 453 zed_conf_write_pid(struct zed_conf *zcp) 454 { 455 const mode_t dirmode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH; 456 const mode_t filemode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH; 457 char buf[PATH_MAX]; 458 int n; 459 char *p; 460 mode_t mask; 461 int rv; 462 463 if (!zcp || !zcp->pid_file) { 464 errno = EINVAL; 465 zed_log_msg(LOG_ERR, "Failed to create PID file: %s", 466 strerror(errno)); 467 return (-1); 468 } 469 assert(zcp->pid_fd == -1); 470 /* 471 * Create PID file directory if needed. 472 */ 473 n = strlcpy(buf, zcp->pid_file, sizeof (buf)); 474 if (n >= sizeof (buf)) { 475 errno = ENAMETOOLONG; 476 zed_log_msg(LOG_ERR, "Failed to create PID file: %s", 477 strerror(errno)); 478 goto err; 479 } 480 p = strrchr(buf, '/'); 481 if (p) 482 *p = '\0'; 483 484 if ((mkdirp(buf, dirmode) < 0) && (errno != EEXIST)) { 485 zed_log_msg(LOG_ERR, "Failed to create directory \"%s\": %s", 486 buf, strerror(errno)); 487 goto err; 488 } 489 /* 490 * Obtain PID file lock. 491 */ 492 mask = umask(0); 493 umask(mask | 022); 494 zcp->pid_fd = open(zcp->pid_file, (O_RDWR | O_CREAT), filemode); 495 umask(mask); 496 if (zcp->pid_fd < 0) { 497 zed_log_msg(LOG_ERR, "Failed to open PID file \"%s\": %s", 498 zcp->pid_file, strerror(errno)); 499 goto err; 500 } 501 rv = zed_file_lock(zcp->pid_fd); 502 if (rv < 0) { 503 zed_log_msg(LOG_ERR, "Failed to lock PID file \"%s\": %s", 504 zcp->pid_file, strerror(errno)); 505 goto err; 506 } else if (rv > 0) { 507 pid_t pid = zed_file_is_locked(zcp->pid_fd); 508 if (pid < 0) { 509 zed_log_msg(LOG_ERR, 510 "Failed to test lock on PID file \"%s\"", 511 zcp->pid_file); 512 } else if (pid > 0) { 513 zed_log_msg(LOG_ERR, 514 "Found PID %d bound to PID file \"%s\"", 515 pid, zcp->pid_file); 516 } else { 517 zed_log_msg(LOG_ERR, 518 "Inconsistent lock state on PID file \"%s\"", 519 zcp->pid_file); 520 } 521 goto err; 522 } 523 /* 524 * Write PID file. 525 */ 526 n = snprintf(buf, sizeof (buf), "%d\n", (int)getpid()); 527 if ((n < 0) || (n >= sizeof (buf))) { 528 errno = ERANGE; 529 zed_log_msg(LOG_ERR, "Failed to write PID file \"%s\": %s", 530 zcp->pid_file, strerror(errno)); 531 } else if (zed_file_write_n(zcp->pid_fd, buf, n) != n) { 532 zed_log_msg(LOG_ERR, "Failed to write PID file \"%s\": %s", 533 zcp->pid_file, strerror(errno)); 534 } else if (fdatasync(zcp->pid_fd) < 0) { 535 zed_log_msg(LOG_ERR, "Failed to sync PID file \"%s\": %s", 536 zcp->pid_file, strerror(errno)); 537 } else { 538 return (0); 539 } 540 541 err: 542 if (zcp->pid_fd >= 0) { 543 (void) close(zcp->pid_fd); 544 zcp->pid_fd = -1; 545 } 546 return (-1); 547 } 548 549 /* 550 * Open and lock the [zcp] state_file. 551 * Return 0 on success, -1 on error. 552 * 553 * FIXME: Move state information into kernel. 554 */ 555 int 556 zed_conf_open_state(struct zed_conf *zcp) 557 { 558 char dirbuf[PATH_MAX]; 559 mode_t dirmode = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH; 560 int n; 561 char *p; 562 int rv; 563 564 if (!zcp || !zcp->state_file) { 565 errno = EINVAL; 566 zed_log_msg(LOG_ERR, "Failed to open state file: %s", 567 strerror(errno)); 568 return (-1); 569 } 570 n = strlcpy(dirbuf, zcp->state_file, sizeof (dirbuf)); 571 if (n >= sizeof (dirbuf)) { 572 errno = ENAMETOOLONG; 573 zed_log_msg(LOG_WARNING, "Failed to open state file: %s", 574 strerror(errno)); 575 return (-1); 576 } 577 p = strrchr(dirbuf, '/'); 578 if (p) 579 *p = '\0'; 580 581 if ((mkdirp(dirbuf, dirmode) < 0) && (errno != EEXIST)) { 582 zed_log_msg(LOG_WARNING, 583 "Failed to create directory \"%s\": %s", 584 dirbuf, strerror(errno)); 585 return (-1); 586 } 587 if (zcp->state_fd >= 0) { 588 if (close(zcp->state_fd) < 0) { 589 zed_log_msg(LOG_WARNING, 590 "Failed to close state file \"%s\": %s", 591 zcp->state_file, strerror(errno)); 592 return (-1); 593 } 594 } 595 if (zcp->do_zero) 596 (void) unlink(zcp->state_file); 597 598 zcp->state_fd = open(zcp->state_file, 599 (O_RDWR | O_CREAT), (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)); 600 if (zcp->state_fd < 0) { 601 zed_log_msg(LOG_WARNING, "Failed to open state file \"%s\": %s", 602 zcp->state_file, strerror(errno)); 603 return (-1); 604 } 605 rv = zed_file_lock(zcp->state_fd); 606 if (rv < 0) { 607 zed_log_msg(LOG_WARNING, "Failed to lock state file \"%s\": %s", 608 zcp->state_file, strerror(errno)); 609 return (-1); 610 } 611 if (rv > 0) { 612 pid_t pid = zed_file_is_locked(zcp->state_fd); 613 if (pid < 0) { 614 zed_log_msg(LOG_WARNING, 615 "Failed to test lock on state file \"%s\"", 616 zcp->state_file); 617 } else if (pid > 0) { 618 zed_log_msg(LOG_WARNING, 619 "Found PID %d bound to state file \"%s\"", 620 pid, zcp->state_file); 621 } else { 622 zed_log_msg(LOG_WARNING, 623 "Inconsistent lock state on state file \"%s\"", 624 zcp->state_file); 625 } 626 return (-1); 627 } 628 return (0); 629 } 630 631 /* 632 * Read the opened [zcp] state_file to obtain the eid & etime of the last event 633 * processed. Write the state from the last event to the [eidp] & [etime] args 634 * passed by reference. Note that etime[] is an array of size 2. 635 * Return 0 on success, -1 on error. 636 */ 637 int 638 zed_conf_read_state(struct zed_conf *zcp, uint64_t *eidp, int64_t etime[]) 639 { 640 ssize_t len; 641 struct iovec iov[3]; 642 ssize_t n; 643 644 if (!zcp || !eidp || !etime) { 645 errno = EINVAL; 646 zed_log_msg(LOG_ERR, 647 "Failed to read state file: %s", strerror(errno)); 648 return (-1); 649 } 650 if (lseek(zcp->state_fd, 0, SEEK_SET) == (off_t)-1) { 651 zed_log_msg(LOG_WARNING, 652 "Failed to reposition state file offset: %s", 653 strerror(errno)); 654 return (-1); 655 } 656 len = 0; 657 iov[0].iov_base = eidp; 658 len += iov[0].iov_len = sizeof (*eidp); 659 iov[1].iov_base = &etime[0]; 660 len += iov[1].iov_len = sizeof (etime[0]); 661 iov[2].iov_base = &etime[1]; 662 len += iov[2].iov_len = sizeof (etime[1]); 663 664 n = readv(zcp->state_fd, iov, 3); 665 if (n == 0) { 666 *eidp = 0; 667 } else if (n < 0) { 668 zed_log_msg(LOG_WARNING, 669 "Failed to read state file \"%s\": %s", 670 zcp->state_file, strerror(errno)); 671 return (-1); 672 } else if (n != len) { 673 errno = EIO; 674 zed_log_msg(LOG_WARNING, 675 "Failed to read state file \"%s\": Read %d of %d bytes", 676 zcp->state_file, n, len); 677 return (-1); 678 } 679 return (0); 680 } 681 682 /* 683 * Write the [eid] & [etime] of the last processed event to the opened 684 * [zcp] state_file. Note that etime[] is an array of size 2. 685 * Return 0 on success, -1 on error. 686 */ 687 int 688 zed_conf_write_state(struct zed_conf *zcp, uint64_t eid, int64_t etime[]) 689 { 690 ssize_t len; 691 struct iovec iov[3]; 692 ssize_t n; 693 694 if (!zcp) { 695 errno = EINVAL; 696 zed_log_msg(LOG_ERR, 697 "Failed to write state file: %s", strerror(errno)); 698 return (-1); 699 } 700 if (lseek(zcp->state_fd, 0, SEEK_SET) == (off_t)-1) { 701 zed_log_msg(LOG_WARNING, 702 "Failed to reposition state file offset: %s", 703 strerror(errno)); 704 return (-1); 705 } 706 len = 0; 707 iov[0].iov_base = &eid; 708 len += iov[0].iov_len = sizeof (eid); 709 iov[1].iov_base = &etime[0]; 710 len += iov[1].iov_len = sizeof (etime[0]); 711 iov[2].iov_base = &etime[1]; 712 len += iov[2].iov_len = sizeof (etime[1]); 713 714 n = writev(zcp->state_fd, iov, 3); 715 if (n < 0) { 716 zed_log_msg(LOG_WARNING, 717 "Failed to write state file \"%s\": %s", 718 zcp->state_file, strerror(errno)); 719 return (-1); 720 } 721 if (n != len) { 722 errno = EIO; 723 zed_log_msg(LOG_WARNING, 724 "Failed to write state file \"%s\": Wrote %d of %d bytes", 725 zcp->state_file, n, len); 726 return (-1); 727 } 728 if (fdatasync(zcp->state_fd) < 0) { 729 zed_log_msg(LOG_WARNING, 730 "Failed to sync state file \"%s\": %s", 731 zcp->state_file, strerror(errno)); 732 return (-1); 733 } 734 return (0); 735 } 736