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 ssize_t watchdog_write_timeout(struct kobj_t * kobj, void * buf, size_t size) { struct watchdog_t * watchdog = (struct watchdog_t *)kobj->priv; int timeout = strtol(buf, NULL, 0); watchdog_set_timeout(watchdog, timeout); return size; }
static int watchdog_open(struct inode *inode, struct file *filp) { if (open_state == WATCHDOG_DRIVER_OPEN) return -EBUSY; wd_expire = 0; watchdog_disable(); watchdog_set_timeout(wdt_margin); watchdog_enable(); printk(KERN_INFO PFX "watchog timer enabled, margin: %ds.\n", wdt_margin); open_state = WATCHDOG_DRIVER_OPEN; return nonseekable_open(inode, filp); }
static int watchdog_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg) { void __user *argp = (void __user *)arg; int margin; switch(cmd) { case WDIOC_GETSUPPORT: return copy_to_user(argp, &sl351x_wdt_ident, sizeof(sl351x_wdt_ident)) ? -EFAULT : 0; case WDIOC_GETSTATUS: case WDIOC_GETBOOTSTATUS: return put_user(0, (int __user*)argp); case WDIOC_KEEPALIVE: watchdog_keepalive(); return 0; case WDIOC_SETTIMEOUT: if (get_user(margin, (int __user*)argp)) return -EFAULT; /* Arbitrary, can't find the card's limits */ if ((margin < 0) || (margin > 60)) return -EINVAL; // watchdog_disable(); wdt_margin = margin; watchdog_set_timeout(margin); watchdog_keepalive(); // watchdog_enable(); /* Fall through */ case WDIOC_GETTIMEOUT: return put_user(wdt_margin, (int *)arg); default: return -ENOIOCTLCMD; } }
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; }
static int sl351x_wdt_resume(struct platform_device *dev) { watchdog_set_timeout(wdt_margin); watchdog_enable(); }
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; }