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