static int watchdog_release(struct inode *inode, struct file *file) { int err = -EBUSY; /* * We only stop the watchdog if we received the magic character * or if WDIOF_MAGICCLOSE is not set. If nowayout was set then * watchdog_stop will fail. */ if (test_and_clear_bit(WDOG_ALLOW_RELEASE, &wdd->status) || !(wdd->info->options & WDIOF_MAGICCLOSE)) err = watchdog_stop(wdd); /* If the watchdog was not stopped, send a keepalive ping */ if (err < 0) { pr_crit("%s: watchdog did not stop!\n", wdd->info->identity); watchdog_ping(wdd); } /* Allow the owner module to be unloaded again */ module_put(wdd->ops->owner); /* make sure that /dev/watchdog can be re-opened */ clear_bit(WDOG_DEV_OPEN, &wdd->status); return 0; }
static int watchdog_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { int i; static struct watchdog_info ident= { 0, 0, "Footbridge Watchdog" }; switch(cmd) { default: return -ENOTTY; case WDIOC_GETSUPPORT: i = verify_area(VERIFY_WRITE, (void*) arg, sizeof(struct watchdog_info)); if (i) return i; else return copy_to_user((struct watchdog_info *)arg, &ident, sizeof(ident)); case WDIOC_GETSTATUS: case WDIOC_GETBOOTSTATUS: return put_user(0,(int *)arg); case WDIOC_KEEPALIVE: watchdog_ping(); return 0; } }
static int watchdog_release(struct inode *inode, struct file *file) { struct watchdog_device *wdd = file->private_data; int err = -EBUSY; /* * We only stop the watchdog if we received the magic character * or if WDIOF_MAGICCLOSE is not set. If nowayout was set then * watchdog_stop will fail. */ if (test_and_clear_bit(WDOG_ALLOW_RELEASE, &wdd->status) || !(wdd->info->options & WDIOF_MAGICCLOSE)) err = watchdog_stop(wdd); /* If the watchdog was not stopped, send a keepalive ping */ if (err < 0) { mutex_lock(&wdd->lock); if (!test_bit(WDOG_UNREGISTERED, &wdd->status)) dev_crit(wdd->dev, "watchdog did not stop!\n"); mutex_unlock(&wdd->lock); watchdog_ping(wdd); } /* Allow the owner module to be unloaded again */ module_put(wdd->ops->owner); /* make sure that /dev/watchdog can be re-opened */ clear_bit(WDOG_DEV_OPEN, &wdd->status); /* Note wdd may be gone after this, do not use after this! */ if (wdd->ops->unref) wdd->ops->unref(wdd); return 0; }
/* * Allow only one person to hold it open */ static int watchdog_open(struct inode *inode, struct file *file) { int ret; if (*CSR_SA110_CNTL & (1 << 13)) return -EBUSY; if (test_and_set_bit(1, &timer_alive)) return -EBUSY; reload = soft_margin * (mem_fclk_21285 / 256); *CSR_TIMER4_CLR = 0; watchdog_ping(); *CSR_TIMER4_CNTL = TIMER_CNTL_ENABLE | TIMER_CNTL_AUTORELOAD | TIMER_CNTL_DIV256; #ifdef ONLY_TESTING ret = request_irq(IRQ_TIMER4, watchdog_fire, 0, "watchdog", NULL); if (ret) { *CSR_TIMER4_CNTL = 0; clear_bit(1, &timer_alive); } #else /* * Setting this bit is irreversible; once enabled, there is * no way to disable the watchdog. */ *CSR_SA110_CNTL |= 1 << 13; ret = 0; #endif nonseekable_open(inode, file); return ret; }
static ssize_t watchdog_write(struct file *file, const char __user *data, size_t len, loff_t *ppos) { struct watchdog_device *wdd = file->private_data; size_t i; char c; if (len == 0) return 0; /* * Note: just in case someone wrote the magic character * five months ago... */ clear_bit(WDOG_ALLOW_RELEASE, &wdd->status); /* scan to see whether or not we got the magic character */ for (i = 0; i != len; i++) { if (get_user(c, data + i)) return -EFAULT; if (c == 'V') set_bit(WDOG_ALLOW_RELEASE, &wdd->status); } /* someone wrote to us, so we send the watchdog a keepalive ping */ watchdog_ping(wdd); return len; }
int main(int argc, char *argv[]) { usec_t t; unsigned i, count; int r; bool slow; log_set_max_level(LOG_DEBUG); log_parse_environment(); r = getenv_bool("SYSTEMD_SLOW_TESTS"); slow = r >= 0 ? r : SYSTEMD_SLOW_TESTS_DEFAULT; t = slow ? 10 * USEC_PER_SEC : 1 * USEC_PER_SEC; count = slow ? 5 : 3; r = watchdog_set_timeout(&t); if (r < 0) log_warning_errno(r, "Failed to open watchdog: %m"); if (r == -EPERM) t = 0; for (i = 0; i < count; i++) { log_info("Pinging..."); r = watchdog_ping(); if (r < 0) log_warning_errno(r, "Failed to ping watchdog: %m"); usleep(t/2); } watchdog_close(true); return 0; }
static long watchdog_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { unsigned int new_margin; int __user *int_arg = (int __user *)arg; int ret = -ENOTTY; switch (cmd) { case WDIOC_GETSUPPORT: ret = 0; if (copy_to_user((void __user *)arg, &ident, sizeof(ident))) ret = -EFAULT; break; case WDIOC_GETSTATUS: case WDIOC_GETBOOTSTATUS: ret = put_user(0, int_arg); break; case WDIOC_KEEPALIVE: watchdog_ping(); ret = 0; break; case WDIOC_SETTIMEOUT: ret = get_user(new_margin, int_arg); if (ret) break; /* Arbitrary, can't find the card's limits */ if (new_margin < 0 || new_margin > 60) { ret = -EINVAL; break; } soft_margin = new_margin; reload = soft_margin * (mem_fclk_21285 / 256); watchdog_ping(); /* Fall */ case WDIOC_GETTIMEOUT: ret = put_user(soft_margin, int_arg); break; } return ret; }
static int watchdog_open(struct inode *inode, struct file *file) { #ifndef CONFIG_HW_RST request_irq(INTC_WATCHDOG_TIMER_BIT_INDEX, watchdog_fire, 0, "watchdog", NULL); #endif watchdog_str9100_hwinit(); watchdog_ping(); return nonseekable_open(inode, file); }
static ssize_t watchdog_write(struct file *file, const char *data, size_t len, loff_t *ppos) { // if (ppos != &file->f_pos) return -ESPIPE; if (len) { watchdog_ping(); return 1; } return 0; }
static ssize_t watchdog_write(struct file *file, const char __user *data, size_t len, loff_t *ppos) { /* * Refresh the timer. */ if (len) watchdog_ping(); return len; }
int main(int argc, char **argv) { pid_t pid; ulog_open(ULOG_KMSG, LOG_DAEMON, "init"); sigaction(SIGTERM, &sa_shutdown, NULL); sigaction(SIGUSR1, &sa_shutdown, NULL); sigaction(SIGUSR2, &sa_shutdown, NULL); early(); cmdline(); watchdog_init(1); pid = fork(); if (!pid) { char *kmod[] = { "/sbin/kmodloader", "/etc/modules-boot.d/", NULL }; if (debug < 3) { int fd = open("/dev/null", O_RDWR); if (fd > -1) { dup2(fd, STDIN_FILENO); dup2(fd, STDOUT_FILENO); dup2(fd, STDERR_FILENO); if (fd > STDERR_FILENO) close(fd); } } execvp(kmod[0], kmod); ERROR("Failed to start kmodloader\n"); exit(-1); } if (pid <= 0) { ERROR("Failed to start kmodloader instance\n"); } else { int i; for (i = 0; i < 120; i++) { if (waitpid(pid, NULL, WNOHANG) > 0) break; sleep(1); watchdog_ping(); } } uloop_init(); preinit(); uloop_run(); return 0; }
static int watchdog_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { int i, new_margin; static struct watchdog_info ident= { WDIOF_SETTIMEOUT, 0, "Footbridge Watchdog" }; switch(cmd) { default: return -ENOTTY; case WDIOC_GETSUPPORT: if(copy_to_user((struct watchdog_info *)arg, &ident, sizeof(ident))) return -EFAULT; return 0; case WDIOC_GETSTATUS: case WDIOC_GETBOOTSTATUS: return put_user(0,(int *)arg); case WDIOC_KEEPALIVE: watchdog_ping(); return 0; case WDIOC_SETTIMEOUT: if (get_user(new_margin, (int *)arg)) return -EFAULT; /* Arbitrary, can't find the card's limits */ if ((new_margin < 0) || (new_margin > 60)) return -EINVAL; soft_margin = new_margin; watchdog_ping(); /* Fall */ case WDIOC_GETTIMEOUT: return put_user(soft_margin, (int *)arg); } }
static int watchdog_release(struct inode *inode, struct file *file) { struct watchdog_core_data *wd_data = file->private_data; struct watchdog_device *wdd; int err = -EBUSY; bool running; mutex_lock(&wd_data->lock); wdd = wd_data->wdd; if (!wdd) goto done; /* * We only stop the watchdog if we received the magic character * or if WDIOF_MAGICCLOSE is not set. If nowayout was set then * watchdog_stop will fail. */ if (!test_bit(WDOG_ACTIVE, &wdd->status)) err = 0; else if (test_and_clear_bit(_WDOG_ALLOW_RELEASE, &wd_data->status) || !(wdd->info->options & WDIOF_MAGICCLOSE)) err = watchdog_stop(wdd); /* If the watchdog was not stopped, send a keepalive ping */ if (err < 0) { pr_crit("watchdog%d: watchdog did not stop!\n", wdd->id); watchdog_ping(wdd); } watchdog_update_worker(wdd); /* make sure that /dev/watchdog can be re-opened */ clear_bit(_WDOG_DEV_OPEN, &wd_data->status); done: running = wdd && watchdog_hw_running(wdd); mutex_unlock(&wd_data->lock); /* * Allow the owner module to be unloaded again unless the watchdog * is still running. If the watchdog is still running, it can not * be stopped, and its driver must not be unloaded. */ if (!running) { module_put(wd_data->cdev.owner); kref_put(&wd_data->kref, watchdog_core_data_release); } return 0; }
static int watchdog_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { int new_margin; static struct watchdog_info ident= { WDIOF_SETTIMEOUT, 0, "Str9100 Watchdog" }; switch(cmd) { case WDIOC_GETSUPPORT: if (copy_to_user((struct watchdog_info *)arg, &ident, sizeof(ident))) return -EFAULT; return 0; case WDIOC_GETSTATUS: case WDIOC_GETBOOTSTATUS: return put_user(0,(int *)arg); case WDIOC_KEEPALIVE: watchdog_ping(); return 0; case WDIOC_SETTIMEOUT: if (get_user(new_margin, (int *)arg)) return -EFAULT; if ((new_margin < 0) || (new_margin > 60)) return -EINVAL; soft_margin = new_margin; watchdog_str9100_hwinit(); watchdog_ping(); case WDIOC_GETTIMEOUT: return put_user(soft_margin, (int *)arg); default: return -ENOTTY; } }
static ssize_t watchdog_write(struct file *file, const char *data, size_t len, loff_t *ppos) { /* Can't seek (pwrite) on this device */ if (ppos != &file->f_pos) return -ESPIPE; /* * Refresh the timer. */ if(len) { watchdog_ping(); return 1; } return 0; }
static int watchdog_open(struct inode *inode, struct file *file) { if(timer_alive) return -EBUSY; /* * Ahead watchdog factor ten, Mr Sulu */ *CSR_TIMER4_CLR = 0; watchdog_ping(); *CSR_TIMER4_CNTL = TIMER_CNTL_ENABLE | TIMER_CNTL_AUTORELOAD | TIMER_CNTL_DIV256; #ifdef ONLY_TESTING request_irq(IRQ_TIMER4, watchdog_fire, 0, "watchdog", NULL); #else *CSR_SA110_CNTL |= 1 << 13; MOD_INC_USE_COUNT; #endif timer_alive = 1; return 0; }
int main(int argc, char *argv[]) { usec_t t = 10 * USEC_PER_SEC; unsigned i; int r; log_set_max_level(LOG_DEBUG); log_parse_environment(); r = watchdog_set_timeout(&t); if (r < 0) log_warning_errno(r, "Failed to open watchdog: %m"); for (i = 0; i < 5; i++) { log_info("Pinging..."); r = watchdog_ping(); if (r < 0) log_warning_errno(r, "Failed to ping watchdog: %m"); usleep(t/2); } watchdog_close(true); return 0; }
int main(int argc, char *argv[]) { bool need_umount, need_swapoff, need_loop_detach, need_dm_detach; bool in_container, use_watchdog = false; _cleanup_free_ char *cgroup = NULL; char *arguments[3]; unsigned retries; int cmd, r; static const char* const dirs[] = {SYSTEM_SHUTDOWN_PATH, NULL}; log_parse_environment(); r = parse_argv(argc, argv); if (r < 0) goto error; /* journald will die if not gone yet. The log target defaults * to console, but may have been changed by command line options. */ log_close_console(); /* force reopen of /dev/console */ log_open(); umask(0022); if (getpid() != 1) { log_error("Not executed by init (PID 1)."); r = -EPERM; goto error; } if (streq(arg_verb, "reboot")) cmd = RB_AUTOBOOT; else if (streq(arg_verb, "poweroff")) cmd = RB_POWER_OFF; else if (streq(arg_verb, "halt")) cmd = RB_HALT_SYSTEM; else if (streq(arg_verb, "kexec")) cmd = LINUX_REBOOT_CMD_KEXEC; else if (streq(arg_verb, "exit")) cmd = 0; /* ignored, just checking that arg_verb is valid */ else { r = -EINVAL; log_error("Unknown action '%s'.", arg_verb); goto error; } cg_get_root_path(&cgroup); use_watchdog = !!getenv("WATCHDOG_USEC"); /* lock us into memory */ mlockall(MCL_CURRENT|MCL_FUTURE); log_info("Sending SIGTERM to remaining processes..."); broadcast_signal(SIGTERM, true, true); log_info("Sending SIGKILL to remaining processes..."); broadcast_signal(SIGKILL, true, false); in_container = detect_container() > 0; need_umount = !in_container; need_swapoff = !in_container; need_loop_detach = !in_container; need_dm_detach = !in_container; /* Unmount all mountpoints, swaps, and loopback devices */ for (retries = 0; retries < FINALIZE_ATTEMPTS; retries++) { bool changed = false; if (use_watchdog) watchdog_ping(); /* Let's trim the cgroup tree on each iteration so that we leave an empty cgroup tree around, so that container managers get a nice notify event when we are down */ if (cgroup) cg_trim(SYSTEMD_CGROUP_CONTROLLER, cgroup, false); if (need_umount) { log_info("Unmounting file systems."); r = umount_all(&changed); if (r == 0) { need_umount = false; log_info("All filesystems unmounted."); } else if (r > 0) log_info("Not all file systems unmounted, %d left.", r); else log_error_errno(r, "Failed to unmount file systems: %m"); } if (need_swapoff) { log_info("Deactivating swaps."); r = swapoff_all(&changed); if (r == 0) { need_swapoff = false; log_info("All swaps deactivated."); } else if (r > 0) log_info("Not all swaps deactivated, %d left.", r); else log_error_errno(r, "Failed to deactivate swaps: %m"); } if (need_loop_detach) { log_info("Detaching loop devices."); r = loopback_detach_all(&changed); if (r == 0) { need_loop_detach = false; log_info("All loop devices detached."); } else if (r > 0) log_info("Not all loop devices detached, %d left.", r); else log_error_errno(r, "Failed to detach loop devices: %m"); } if (need_dm_detach) { log_info("Detaching DM devices."); r = dm_detach_all(&changed); if (r == 0) { need_dm_detach = false; log_info("All DM devices detached."); } else if (r > 0) log_info("Not all DM devices detached, %d left.", r); else log_error_errno(r, "Failed to detach DM devices: %m"); } if (!need_umount && !need_swapoff && !need_loop_detach && !need_dm_detach) { if (retries > 0) log_info("All filesystems, swaps, loop devices, DM devices detached."); /* Yay, done */ goto initrd_jump; } /* If in this iteration we didn't manage to * unmount/deactivate anything, we simply give up */ if (!changed) { log_info("Cannot finalize remaining%s%s%s%s continuing.", need_umount ? " file systems," : "", need_swapoff ? " swap devices," : "", need_loop_detach ? " loop devices," : "", need_dm_detach ? " DM devices," : ""); goto initrd_jump; } log_debug("After %u retries, couldn't finalize remaining %s%s%s%s trying again.", retries + 1, need_umount ? " file systems," : "", need_swapoff ? " swap devices," : "", need_loop_detach ? " loop devices," : "", need_dm_detach ? " DM devices," : ""); } log_error("Too many iterations, giving up."); initrd_jump: arguments[0] = NULL; arguments[1] = arg_verb; arguments[2] = NULL; execute_directories(dirs, DEFAULT_TIMEOUT_USEC, arguments); if (!in_container && !in_initrd() && access("/run/initramfs/shutdown", X_OK) == 0) { r = switch_root_initramfs(); if (r >= 0) { argv[0] = (char*) "/shutdown"; setsid(); make_console_stdio(); log_info("Successfully changed into root pivot.\n" "Returning to initrd..."); execv("/shutdown", argv); log_error_errno(errno, "Failed to execute shutdown binary: %m"); } else log_error_errno(r, "Failed to switch root to \"/run/initramfs\": %m"); } if (need_umount || need_swapoff || need_loop_detach || need_dm_detach) log_error("Failed to finalize %s%s%s%s ignoring", need_umount ? " file systems," : "", need_swapoff ? " swap devices," : "", need_loop_detach ? " loop devices," : "", need_dm_detach ? " DM devices," : ""); /* The kernel will automaticall flush ATA disks and suchlike * on reboot(), but the file systems need to be synce'd * explicitly in advance. So let's do this here, but not * needlessly slow down containers. */ if (!in_container) sync(); if (streq(arg_verb, "exit")) { if (in_container) exit(arg_exit_code); else { /* We cannot exit() on the host, fallback on another * method. */ cmd = RB_POWER_OFF; } } switch (cmd) { case LINUX_REBOOT_CMD_KEXEC: if (!in_container) { /* We cheat and exec kexec to avoid doing all its work */ pid_t pid; log_info("Rebooting with kexec."); pid = fork(); if (pid < 0) log_error_errno(errno, "Failed to fork: %m"); else if (pid == 0) { const char * const args[] = { KEXEC, "-e", NULL }; /* Child */ execv(args[0], (char * const *) args); _exit(EXIT_FAILURE); } else wait_for_terminate_and_warn("kexec", pid, true); } cmd = RB_AUTOBOOT; /* Fall through */ case RB_AUTOBOOT: if (!in_container) { _cleanup_free_ char *param = NULL; if (read_one_line_file(REBOOT_PARAM_FILE, ¶m) >= 0) { log_info("Rebooting with argument '%s'.", param); syscall(SYS_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_RESTART2, param); } } log_info("Rebooting."); break; case RB_POWER_OFF: log_info("Powering off."); break; case RB_HALT_SYSTEM: log_info("Halting system."); break; default: assert_not_reached("Unknown magic"); } reboot(cmd); if (errno == EPERM && in_container) { /* If we are in a container, and we lacked * CAP_SYS_BOOT just exit, this will kill our * container for good. */ log_info("Exiting container."); exit(0); } r = log_error_errno(errno, "Failed to invoke reboot(): %m"); error: log_emergency_errno(r, "Critical error while doing system shutdown: %m"); freeze(); }
int main(int argc, char *argv[]) { int cmd, r; unsigned retries; bool need_umount = true, need_swapoff = true, need_loop_detach = true, need_dm_detach = true; bool in_container, use_watchdog = false; char *arguments[3]; log_parse_environment(); log_set_target(LOG_TARGET_CONSOLE); /* syslog will die if not gone yet */ log_open(); umask(0022); if (getpid() != 1) { log_error("Not executed by init (pid 1)."); r = -EPERM; goto error; } if (argc != 2) { log_error("Invalid number of arguments."); r = -EINVAL; goto error; } in_container = detect_container(NULL) > 0; if (streq(argv[1], "reboot")) cmd = RB_AUTOBOOT; else if (streq(argv[1], "poweroff")) cmd = RB_POWER_OFF; else if (streq(argv[1], "halt")) cmd = RB_HALT_SYSTEM; else if (streq(argv[1], "kexec")) cmd = LINUX_REBOOT_CMD_KEXEC; else { log_error("Unknown action '%s'.", argv[1]); r = -EINVAL; goto error; } use_watchdog = !!getenv("WATCHDOG_USEC"); /* lock us into memory */ mlockall(MCL_CURRENT|MCL_FUTURE); log_info("Sending SIGTERM to remaining processes..."); broadcast_signal(SIGTERM, true); log_info("Sending SIGKILL to remaining processes..."); broadcast_signal(SIGKILL, true); if (in_container) { need_swapoff = false; need_dm_detach = false; need_loop_detach = false; } /* Unmount all mountpoints, swaps, and loopback devices */ for (retries = 0; retries < FINALIZE_ATTEMPTS; retries++) { bool changed = false; if (use_watchdog) watchdog_ping(); if (need_umount) { log_info("Unmounting file systems."); r = umount_all(&changed); if (r == 0) need_umount = false; else if (r > 0) log_info("Not all file systems unmounted, %d left.", r); else log_error("Failed to unmount file systems: %s", strerror(-r)); } if (need_swapoff) { log_info("Disabling swaps."); r = swapoff_all(&changed); if (r == 0) need_swapoff = false; else if (r > 0) log_info("Not all swaps are turned off, %d left.", r); else log_error("Failed to turn off swaps: %s", strerror(-r)); } if (need_loop_detach) { log_info("Detaching loop devices."); r = loopback_detach_all(&changed); if (r == 0) need_loop_detach = false; else if (r > 0) log_info("Not all loop devices detached, %d left.", r); else log_error("Failed to detach loop devices: %s", strerror(-r)); } if (need_dm_detach) { log_info("Detaching DM devices."); r = dm_detach_all(&changed); if (r == 0) need_dm_detach = false; else if (r > 0) log_warning("Not all DM devices detached, %d left.", r); else log_error("Failed to detach DM devices: %s", strerror(-r)); } if (!need_umount && !need_swapoff && !need_loop_detach && !need_dm_detach) { if (retries > 0) log_info("All filesystems, swaps, loop devices, DM devices detached."); /* Yay, done */ break; } /* If in this iteration we didn't manage to * unmount/deactivate anything, we simply give up */ if (!changed) { log_error("Cannot finalize remaining file systems and devices, giving up."); break; } log_debug("Couldn't finalize remaining file systems and devices after %u retries, trying again.", retries+1); } if (retries >= FINALIZE_ATTEMPTS) log_error("Too many iterations, giving up."); arguments[0] = NULL; arguments[1] = argv[1]; arguments[2] = NULL; execute_directory(SYSTEM_SHUTDOWN_PATH, NULL, arguments); if (!in_container && access("/run/initramfs/shutdown", X_OK) == 0) { if (prepare_new_root() >= 0 && pivot_to_new_root() >= 0) { execv("/shutdown", argv); log_error("Failed to execute shutdown binary: %m"); } } if (cmd == LINUX_REBOOT_CMD_KEXEC) { if (!in_container) { /* We cheat and exec kexec to avoid doing all its work */ pid_t pid = fork(); if (pid < 0) log_error("Could not fork: %m. Falling back to normal reboot."); else if (pid > 0) { wait_for_terminate_and_warn("kexec", pid); log_warning("kexec failed. Falling back to normal reboot."); } else { /* Child */ const char *args[3] = { "/sbin/kexec", "-e", NULL }; execv(args[0], (char * const *) args); return EXIT_FAILURE; } } cmd = RB_AUTOBOOT; } reboot(cmd); if (errno == EPERM && in_container) { /* If we are in a container, and we lacked * CAP_SYS_BOOT just exit, this will kill our * container for good. */ log_error("Exiting container."); exit(0); } log_error("Failed to invoke reboot(): %m"); r = -errno; error: log_error("Critical error while doing system shutdown: %s", strerror(-r)); freeze(); return EXIT_FAILURE; }
static void watchdog_timeout_cb(struct uloop_timeout *t) { watchdog_ping(); uloop_timeout_set(t, wdt_frequency * 1000); }
static long watchdog_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { struct watchdog_device *wdd = file->private_data; void __user *argp = (void __user *)arg; int __user *p = argp; unsigned int val; int err; err = watchdog_ioctl_op(wdd, cmd, arg); if (err != -ENOIOCTLCMD) return err; switch (cmd) { case WDIOC_GETSUPPORT: return copy_to_user(argp, wdd->info, sizeof(struct watchdog_info)) ? -EFAULT : 0; case WDIOC_GETSTATUS: err = watchdog_get_status(wdd, &val); if (err) return err; return put_user(val, p); case WDIOC_GETBOOTSTATUS: return put_user(wdd->bootstatus, p); case WDIOC_SETOPTIONS: if (get_user(val, p)) return -EFAULT; if (val & WDIOS_DISABLECARD) { err = watchdog_stop(wdd); if (err < 0) return err; } if (val & WDIOS_ENABLECARD) { err = watchdog_start(wdd); if (err < 0) return err; } return 0; case WDIOC_KEEPALIVE: if (!(wdd->info->options & WDIOF_KEEPALIVEPING)) return -EOPNOTSUPP; watchdog_ping(wdd); return 0; case WDIOC_SETTIMEOUT: if (get_user(val, p)) return -EFAULT; err = watchdog_set_timeout(wdd, val); if (err < 0) return err; /* If the watchdog is active then we send a keepalive ping * to make sure that the watchdog keep's running (and if * possible that it takes the new timeout) */ watchdog_ping(wdd); /* Fall */ case WDIOC_GETTIMEOUT: /* timeout == 0 means that we don't know the timeout */ if (wdd->timeout == 0) return -EOPNOTSUPP; return put_user(wdd->timeout, p); case WDIOC_GETTIMELEFT: err = watchdog_get_timeleft(wdd, &val); if (err) return err; return put_user(val, p); default: return -ENOTTY; } }
static long watchdog_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { struct watchdog_core_data *wd_data = file->private_data; void __user *argp = (void __user *)arg; struct watchdog_device *wdd; int __user *p = argp; unsigned int val; int err; mutex_lock(&wd_data->lock); wdd = wd_data->wdd; if (!wdd) { err = -ENODEV; goto out_ioctl; } err = watchdog_ioctl_op(wdd, cmd, arg); if (err != -ENOIOCTLCMD) goto out_ioctl; switch (cmd) { case WDIOC_GETSUPPORT: err = copy_to_user(argp, wdd->info, sizeof(struct watchdog_info)) ? -EFAULT : 0; break; case WDIOC_GETSTATUS: val = watchdog_get_status(wdd); err = put_user(val, p); break; case WDIOC_GETBOOTSTATUS: err = put_user(wdd->bootstatus, p); break; case WDIOC_SETOPTIONS: if (get_user(val, p)) { err = -EFAULT; break; } if (val & WDIOS_DISABLECARD) { err = watchdog_stop(wdd); if (err < 0) break; } if (val & WDIOS_ENABLECARD) err = watchdog_start(wdd); break; case WDIOC_KEEPALIVE: if (!(wdd->info->options & WDIOF_KEEPALIVEPING)) { err = -EOPNOTSUPP; break; } err = watchdog_ping(wdd); break; case WDIOC_SETTIMEOUT: if (get_user(val, p)) { err = -EFAULT; break; } err = watchdog_set_timeout(wdd, val); if (err < 0) break; /* If the watchdog is active then we send a keepalive ping * to make sure that the watchdog keep's running (and if * possible that it takes the new timeout) */ err = watchdog_ping(wdd); if (err < 0) break; /* Fall */ case WDIOC_GETTIMEOUT: /* timeout == 0 means that we don't know the timeout */ if (wdd->timeout == 0) { err = -EOPNOTSUPP; break; } err = put_user(wdd->timeout, p); break; case WDIOC_GETTIMELEFT: err = watchdog_get_timeleft(wdd, &val); if (err < 0) break; err = put_user(val, p); break; case WDIOC_SETPRETIMEOUT: if (get_user(val, p)) { err = -EFAULT; break; } err = watchdog_set_pretimeout(wdd, val); break; case WDIOC_GETPRETIMEOUT: err = put_user(wdd->pretimeout, p); break; default: err = -ENOTTY; break; } out_ioctl: mutex_unlock(&wd_data->lock); return err; }
int main(int argc, char *argv[]) { bool need_umount, need_swapoff, need_loop_detach, need_dm_detach; bool in_container, use_watchdog = false, can_initrd; _cleanup_free_ char *cgroup = NULL; char *arguments[3]; int cmd, r, umount_log_level = LOG_INFO; static const char* const dirs[] = {SYSTEM_SHUTDOWN_PATH, NULL}; char *watchdog_device; /* The log target defaults to console, but the original systemd process will pass its log target in through a * command line argument, which will override this default. Also, ensure we'll never log to the journal or * syslog, as these logging daemons are either already dead or will die very soon. */ log_set_target(LOG_TARGET_CONSOLE); log_set_prohibit_ipc(true); log_parse_environment(); r = parse_argv(argc, argv); if (r < 0) goto error; log_open(); umask(0022); if (getpid_cached() != 1) { log_error("Not executed by init (PID 1)."); r = -EPERM; goto error; } if (streq(arg_verb, "reboot")) cmd = RB_AUTOBOOT; else if (streq(arg_verb, "poweroff")) cmd = RB_POWER_OFF; else if (streq(arg_verb, "halt")) cmd = RB_HALT_SYSTEM; else if (streq(arg_verb, "kexec")) cmd = LINUX_REBOOT_CMD_KEXEC; else if (streq(arg_verb, "exit")) cmd = 0; /* ignored, just checking that arg_verb is valid */ else { log_error("Unknown action '%s'.", arg_verb); r = -EINVAL; goto error; } (void) cg_get_root_path(&cgroup); in_container = detect_container() > 0; use_watchdog = getenv("WATCHDOG_USEC"); watchdog_device = getenv("WATCHDOG_DEVICE"); if (watchdog_device) { r = watchdog_set_device(watchdog_device); if (r < 0) log_warning_errno(r, "Failed to set watchdog device to %s, ignoring: %m", watchdog_device); } /* Lock us into memory */ (void) mlockall(MCL_CURRENT|MCL_FUTURE); /* Synchronize everything that is not written to disk yet at this point already. This is a good idea so that * slow IO is processed here already and the final process killing spree is not impacted by processes * desperately trying to sync IO to disk within their timeout. Do not remove this sync, data corruption will * result. */ if (!in_container) sync_with_progress(); disable_coredumps(); log_info("Sending SIGTERM to remaining processes..."); broadcast_signal(SIGTERM, true, true, arg_timeout); log_info("Sending SIGKILL to remaining processes..."); broadcast_signal(SIGKILL, true, false, arg_timeout); need_umount = !in_container; need_swapoff = !in_container; need_loop_detach = !in_container; need_dm_detach = !in_container; can_initrd = !in_container && !in_initrd() && access("/run/initramfs/shutdown", X_OK) == 0; /* Unmount all mountpoints, swaps, and loopback devices */ for (;;) { bool changed = false; if (use_watchdog) watchdog_ping(); /* Let's trim the cgroup tree on each iteration so that we leave an empty cgroup tree around, so that container managers get a nice notify event when we are down */ if (cgroup) cg_trim(SYSTEMD_CGROUP_CONTROLLER, cgroup, false); if (need_umount) { log_info("Unmounting file systems."); r = umount_all(&changed, umount_log_level); if (r == 0) { need_umount = false; log_info("All filesystems unmounted."); } else if (r > 0) log_info("Not all file systems unmounted, %d left.", r); else log_error_errno(r, "Failed to unmount file systems: %m"); } if (need_swapoff) { log_info("Deactivating swaps."); r = swapoff_all(&changed); if (r == 0) { need_swapoff = false; log_info("All swaps deactivated."); } else if (r > 0) log_info("Not all swaps deactivated, %d left.", r); else log_error_errno(r, "Failed to deactivate swaps: %m"); } if (need_loop_detach) { log_info("Detaching loop devices."); r = loopback_detach_all(&changed, umount_log_level); if (r == 0) { need_loop_detach = false; log_info("All loop devices detached."); } else if (r > 0) log_info("Not all loop devices detached, %d left.", r); else log_error_errno(r, "Failed to detach loop devices: %m"); } if (need_dm_detach) { log_info("Detaching DM devices."); r = dm_detach_all(&changed, umount_log_level); if (r == 0) { need_dm_detach = false; log_info("All DM devices detached."); } else if (r > 0) log_info("Not all DM devices detached, %d left.", r); else log_error_errno(r, "Failed to detach DM devices: %m"); } if (!need_umount && !need_swapoff && !need_loop_detach && !need_dm_detach) { log_info("All filesystems, swaps, loop devices and DM devices detached."); /* Yay, done */ break; } if (!changed && umount_log_level == LOG_INFO && !can_initrd) { /* There are things we cannot get rid of. Loop one more time * with LOG_ERR to inform the user. Note that we don't need * to do this if there is a initrd to switch to, because that * one is likely to get rid of the remounting mounts. If not, * it will log about them. */ umount_log_level = LOG_ERR; continue; } /* If in this iteration we didn't manage to * unmount/deactivate anything, we simply give up */ if (!changed) { log_info("Cannot finalize remaining%s%s%s%s continuing.", need_umount ? " file systems," : "", need_swapoff ? " swap devices," : "", need_loop_detach ? " loop devices," : "", need_dm_detach ? " DM devices," : ""); break; } log_debug("Couldn't finalize remaining %s%s%s%s trying again.", need_umount ? " file systems," : "", need_swapoff ? " swap devices," : "", need_loop_detach ? " loop devices," : "", need_dm_detach ? " DM devices," : ""); } /* We're done with the watchdog. */ watchdog_free_device(); arguments[0] = NULL; arguments[1] = arg_verb; arguments[2] = NULL; execute_directories(dirs, DEFAULT_TIMEOUT_USEC, NULL, NULL, arguments, NULL); (void) rlimit_nofile_safe(); if (can_initrd) { r = switch_root_initramfs(); if (r >= 0) { argv[0] = (char*) "/shutdown"; (void) setsid(); (void) make_console_stdio(); log_info("Successfully changed into root pivot.\n" "Returning to initrd..."); execv("/shutdown", argv); log_error_errno(errno, "Failed to execute shutdown binary: %m"); } else log_error_errno(r, "Failed to switch root to \"/run/initramfs\": %m"); } if (need_umount || need_swapoff || need_loop_detach || need_dm_detach) log_error("Failed to finalize %s%s%s%s ignoring", need_umount ? " file systems," : "", need_swapoff ? " swap devices," : "", need_loop_detach ? " loop devices," : "", need_dm_detach ? " DM devices," : ""); /* The kernel will automatically flush ATA disks and suchlike on reboot(), but the file systems need to be * sync'ed explicitly in advance. So let's do this here, but not needlessly slow down containers. Note that we * sync'ed things already once above, but we did some more work since then which might have caused IO, hence * let's do it once more. Do not remove this sync, data corruption will result. */ if (!in_container) sync_with_progress(); if (streq(arg_verb, "exit")) { if (in_container) return arg_exit_code; cmd = RB_POWER_OFF; /* We cannot exit() on the host, fallback on another method. */ } switch (cmd) { case LINUX_REBOOT_CMD_KEXEC: if (!in_container) { /* We cheat and exec kexec to avoid doing all its work */ log_info("Rebooting with kexec."); r = safe_fork("(sd-kexec)", FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_LOG|FORK_WAIT, NULL); if (r == 0) { const char * const args[] = { KEXEC, "-e", NULL }; /* Child */ execv(args[0], (char * const *) args); _exit(EXIT_FAILURE); } /* If we are still running, then the kexec can't have worked, let's fall through */ } cmd = RB_AUTOBOOT; _fallthrough_; case RB_AUTOBOOT: (void) reboot_with_parameter(REBOOT_LOG); log_info("Rebooting."); break; case RB_POWER_OFF: log_info("Powering off."); break; case RB_HALT_SYSTEM: log_info("Halting system."); break; default: assert_not_reached("Unknown magic"); } (void) reboot(cmd); if (errno == EPERM && in_container) { /* If we are in a container, and we lacked * CAP_SYS_BOOT just exit, this will kill our * container for good. */ log_info("Exiting container."); return EXIT_SUCCESS; } r = log_error_errno(errno, "Failed to invoke reboot(): %m"); error: log_emergency_errno(r, "Critical error while doing system shutdown: %m"); freeze(); }