sys-utils/wdctl.c

   1 /*
   2  * wdctl(8) - show hardware watchdog status
   3  *
   4  * Copyright (C) 2012 Lennart Poettering
   5  * Copyright (C) 2012 Karel Zak <kzak@redhat.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2, or (at your option) any
  10  * later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21 #include <sys/ioctl.h>
  22 #include <getopt.h>
  23 #include <stdio.h>
  24 #include <signal.h>
  25 #include <assert.h>
  26 #include <linux/watchdog.h>
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <unistd.h>
  30
  31 #include <libsmartcols.h>
  32
  33 #include "nls.h"
  34 #include "c.h"
  35 #include "xalloc.h"
  36 #include "closestream.h"
  37 #include "optutils.h"
  38 #include "pathnames.h"
  39 #include "strutils.h"
  40 #include "carefulputc.h"
  41 #include "path.h"
  42 #include "strv.h"
  43
  44 /*
  45  * since 2.6.18
  46  */
  47 #ifndef WDIOC_SETPRETIMEOUT
  48 # define WDIOC_SETPRETIMEOUT    _IOWR(WATCHDOG_IOCTL_BASE, 8, int)
  49 # define WDIOC_GETPRETIMEOUT    _IOR(WATCHDOG_IOCTL_BASE, 9, int)
  50 # define WDIOC_GETTIMELEFT      _IOR(WATCHDOG_IOCTL_BASE, 10, int)
  51 # define WDIOF_POWEROVER        0x0040  /* Power over voltage */
  52 # define WDIOF_SETTIMEOUT       0x0080  /* Set timeout (in seconds) */
  53 # define WDIOF_MAGICCLOSE       0x0100  /* Supports magic close char */
  54 # define WDIOF_PRETIMEOUT       0x0200  /* Pretimeout (in seconds), get/set */
  55 # define WDIOF_KEEPALIVEPING    0x8000  /* Keep alive ping reply */
  56 #endif
  57
  58 /*
  59  * since 3.5
  60  */
  61 #ifndef WDIOF_ALARMONLY
  62 # define WDIOF_ALARMONLY        0x0400  /* Watchdog triggers a management or
  63                                            other external alarm not a reboot */
  64 #endif
  65
  66 struct wdflag {
  67         uint32_t        flag;
  68         const char      *name;
  69         const char      *description;
  70 };
  71
  72 static const struct wdflag wdflags[] = {
  73         { WDIOF_CARDRESET,     "CARDRESET",  N_("Card previously reset the CPU") },
  74         { WDIOF_EXTERN1,       "EXTERN1",    N_("External relay 1") },
  75         { WDIOF_EXTERN2,       "EXTERN2",    N_("External relay 2") },
  76         { WDIOF_FANFAULT,      "FANFAULT",   N_("Fan failed") },
  77         { WDIOF_KEEPALIVEPING, "KEEPALIVEPING", N_("Keep alive ping reply") },
  78         { WDIOF_MAGICCLOSE,    "MAGICCLOSE", N_("Supports magic close char") },
  79         { WDIOF_OVERHEAT,      "OVERHEAT",   N_("Reset due to CPU overheat") },
  80         { WDIOF_POWEROVER,     "POWEROVER",  N_("Power over voltage") },
  81         { WDIOF_POWERUNDER,    "POWERUNDER", N_("Power bad/power fault") },
  82         { WDIOF_PRETIMEOUT,    "PRETIMEOUT", N_("Pretimeout (in seconds)") },
  83         { WDIOF_SETTIMEOUT,    "SETTIMEOUT", N_("Set timeout (in seconds)") },
  84         { WDIOF_ALARMONLY,     "ALARMONLY",  N_("Not trigger reboot") }
  85 };
  86
  87
  88 /* column names */
  89 struct colinfo {
  90         const char *name; /* header */
  91         double     whint; /* width hint (N < 1 is in percent of termwidth) */
  92         int        flags; /* SCOLS_FL_* */
  93         const char *help;
  94 };
  95
  96 enum { COL_FLAG, COL_DESC, COL_STATUS, COL_BSTATUS, COL_DEVICE };
  97
  98 /* columns descriptions */
  99 static struct colinfo infos[] = {
 100         [COL_FLAG]    = { "FLAG",        14,  0, N_("flag name") },
 101         [COL_DESC]    = { "DESCRIPTION", 0.1, SCOLS_FL_TRUNC, N_("flag description") },
 102         [COL_STATUS]  = { "STATUS",      1,   SCOLS_FL_RIGHT, N_("flag status") },
 103         [COL_BSTATUS] = { "BOOT-STATUS", 1,   SCOLS_FL_RIGHT, N_("flag boot status") },
 104         [COL_DEVICE]  = { "DEVICE",      0.1, 0, N_("watchdog device name") }
 105
 106 };
 107
 108 static int columns[ARRAY_SIZE(infos) * 2];
 109 static int ncolumns;
 110
 111 struct wd_device {
 112         const char      *devpath;
 113         struct path_cxt *sysfs;
 114
 115         char            *governor;
 116         char            **available_governors;
 117
 118         int             timeout;
 119         int             timeleft;
 120         int             pretimeout;
 121
 122         uint32_t        status;
 123         uint32_t        bstatus;
 124         int             nowayout;
 125
 126         struct watchdog_info ident;
 127
 128         unsigned int    has_timeout : 1,
 129                         has_timeleft : 1,
 130                         has_pretimeout : 1,
 131                         has_nowayout : 1,
 132                         no_sysfs : 1;
 133 };
 134
 135 struct wd_control {
 136         /* set */
 137         int             timeout;                        /* --settimeout */
 138         int             pretimeout;                     /* --setpretimeout */
 139         const char      *governor;                      /* --setpregovernor */
 140         unsigned int    set_timeout : 1,
 141                         set_pretimeout : 1;
 142
 143         /* output */
 144         unsigned int    show_oneline : 1,
 145                         show_raw : 1,
 146                         hide_headings : 1,
 147                         hide_flags : 1,
 148                         hide_ident : 1,
 149                         hide_timeouts : 1;
 150 };
 151
 152 #define want_set(_ctl)          ((_ctl)->set_timeout \
 153                                   || (_ctl)->set_pretimeout \
 154                                   || (_ctl)->governor)
 155
 156 /* converts flag name to flag bit */
 157 static long name2bit(const char *name, size_t namesz)
 158 {
 159         size_t i;
 160
 161         for (i = 0; i < ARRAY_SIZE(wdflags); i++) {
 162                 const char *cn = wdflags[i].name;
 163                 if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
 164                         return wdflags[i].flag;
 165         }
 166         warnx(_("unknown flag: %s"), name);
 167         return -1;
 168 }
 169
 170 static int column2id(const char *name, size_t namesz)
 171 {
 172         size_t i;
 173
 174         for (i = 0; i < ARRAY_SIZE(infos); i++) {
 175                 const char *cn = infos[i].name;
 176                 if (!strncasecmp(name, cn, namesz) && !*(cn + namesz))
 177                         return i;
 178         }
 179         warnx(_("unknown column: %s"), name);
 180         return -1;
 181 }
 182
 183 static int get_column_id(int num)
 184 {
 185         assert(num < ncolumns);
 186         assert(columns[num] < (int) ARRAY_SIZE(infos));
 187
 188         return columns[num];
 189 }
 190
 191 static struct colinfo *get_column_info(unsigned num)
 192 {
 193         return &infos[ get_column_id(num) ];
 194 }
 195
 196 /* We preffer cdev /dev/watchdog0 as this device has node in
 197  * /sys/class/watchdog/. The old miscdev /dev/watchdog is fallback for old
 198  * systemds only.
 199  */
 200 static const char *get_default_device(void)
 201 {
 202         const char **p;
 203         static const char *devs[] = {
 204                 "/dev/watchdog0",
 205                 "/dev/watchdog",
 206                 NULL
 207         };
 208
 209         for (p = devs; *p; p++) {
 210                 if (access(*p, F_OK) == 0)
 211                         return *p;
 212         }
 213
 214         return NULL;
 215 }
 216
 217 static void __attribute__((__noreturn__)) usage(void)
 218 {
 219         FILE *out = stdout;
 220         size_t i;
 221         const char *dflt = get_default_device();
 222
 223         fputs(USAGE_HEADER, out);
 224         fprintf(out,
 225               _(" %s [options] [<device> ...]\n"), program_invocation_short_name);
 226
 227         fputs(USAGE_SEPARATOR, out);
 228         fputs(_("Show the status of the hardware watchdog.\n"), out);
 229
 230         fputs(USAGE_OPTIONS, out);
 231         fputs(_(" -f, --flags <list>     print selected flags only\n"
 232                 " -F, --noflags          don't print information about flags\n"
 233                 " -I, --noident          don't print watchdog identity information\n"
 234                 " -n, --noheadings       don't print headings for flags table\n"
 235                 " -O, --oneline          print all information on one line\n"
 236                 " -o, --output <list>    output columns of the flags\n"
 237                 " -p, --setpretimeout <sec> set watchdog pre-timeout\n"
 238                 " -g, --setpregovernor <name> set pre-timeout governor\n"
 239                 " -r, --raw              use raw output format for flags table\n"
 240                 " -T, --notimeouts       don't print watchdog timeouts\n"
 241                 " -s, --settimeout <sec> set watchdog timeout\n"
 242                 " -x, --flags-only       print only flags table (same as -I -T)\n"), out);
 243
 244         fputs(USAGE_SEPARATOR, out);
 245         printf(USAGE_HELP_OPTIONS(24));
 246         fputs(USAGE_SEPARATOR, out);
 247
 248         if (dflt)
 249                 fprintf(out, _("The default device is %s.\n"), dflt);
 250         else
 251                 fprintf(out, _("No default device is available.\n"));
 252
 253         fputs(USAGE_COLUMNS, out);
 254         for (i = 0; i < ARRAY_SIZE(infos); i++)
 255                 fprintf(out, " %13s  %s\n", infos[i].name, _(infos[i].help));
 256
 257         printf(USAGE_MAN_TAIL("wdctl(8)"));
 258
 259         exit(EXIT_SUCCESS);
 260 }
 261
 262 static struct path_cxt *get_sysfs(struct wd_device *wd)
 263 {
 264         struct path_cxt *sys;
 265         struct stat st;
 266
 267         if (wd->no_sysfs)
 268                 return NULL;
 269         if (wd->sysfs)
 270                 return wd->sysfs;
 271         if (stat(wd->devpath, &st) != 0)
 272                 goto nosysfs;
 273
 274         sys = ul_new_path(_PATH_SYS_DEVCHAR "/%u:%u",
 275                         major(st.st_rdev), minor(st.st_rdev));
 276         if (!sys)
 277                 return NULL;
 278
 279         if (ul_path_get_dirfd(sys) < 0)
 280                 goto nosysfs;           /* device not in /sys */
 281
 282         if (ul_path_access(sys, F_OK, "identity") != 0)
 283                 goto nosysfs;           /* no info in /sys (old miscdev?) */
 284
 285         wd->sysfs = sys;
 286         return sys;
 287 nosysfs:
 288         wd->no_sysfs = 1;
 289         return NULL;
 290 }
 291
 292 static void add_flag_line(struct libscols_table *table, struct wd_device *wd, const struct wdflag *fl)
 293 {
 294         int i;
 295         struct libscols_line *line;
 296
 297         line = scols_table_new_line(table, NULL);
 298         if (!line) {
 299                 warn(_("failed to allocate output line"));
 300                 return;
 301         }
 302
 303         for (i = 0; i < ncolumns; i++) {
 304                 const char *str = NULL;
 305
 306                 switch (get_column_id(i)) {
 307                 case COL_FLAG:
 308                         str = fl->name;
 309                         break;
 310                 case COL_DESC:
 311                         str = fl->description;
 312                         break;
 313                 case COL_STATUS:
 314                         str = wd->status & fl->flag ? "1" : "0";
 315                         break;
 316                 case COL_BSTATUS:
 317                         str = wd->bstatus & fl->flag ? "1" : "0";
 318                         break;
 319                 case COL_DEVICE:
 320                         str = wd->devpath;
 321                         break;
 322                 default:
 323                         break;
 324                 }
 325
 326                 if (str && scols_line_set_data(line, i, str)) {
 327                         warn(_("failed to add output data"));
 328                         break;
 329                 }
 330         }
 331 }
 332
 333 static int show_flags(struct wd_control *ctl, struct wd_device *wd, uint32_t wanted)
 334 {
 335         size_t i;
 336         int rc = -1;
 337         struct libscols_table *table;
 338         uint32_t flags;
 339
 340         /* information about supported bits is probably missing in /sys */
 341         if (!wd->ident.options)
 342                 return 0;
 343
 344         scols_init_debug(0);
 345
 346         /* create output table */
 347         table = scols_new_table();
 348         if (!table) {
 349                 warn(_("failed to allocate output table"));
 350                 return -1;
 351         }
 352         scols_table_enable_raw(table, ctl->show_raw);
 353         scols_table_enable_noheadings(table, ctl->hide_headings);
 354
 355         /* define columns */
 356         for (i = 0; i < (size_t) ncolumns; i++) {
 357                 struct colinfo *col = get_column_info(i);
 358
 359                 if (!scols_table_new_column(table, col->name, col->whint, col->flags)) {
 360                         warnx(_("failed to allocate output column"));
 361                         goto done;
 362                 }
 363         }
 364
 365         /* fill-in table with data
 366          * -- one line for each supported flag (option)  */
 367         flags = wd->ident.options;
 368
 369         for (i = 0; i < ARRAY_SIZE(wdflags); i++) {
 370                 if (wanted && !(wanted & wdflags[i].flag))
 371                         ; /* ignore */
 372                 else if (flags & wdflags[i].flag)
 373                         add_flag_line(table, wd, &wdflags[i]);
 374
 375                 flags &= ~wdflags[i].flag;
 376         }
 377
 378         if (flags)
 379                 warnx(_("%s: unknown flags 0x%x\n"), wd->devpath, flags);
 380
 381         scols_print_table(table);
 382         rc = 0;
 383 done:
 384         scols_unref_table(table);
 385         return rc;
 386 }
 387
 388 /*
 389  * Warning: successfully opened watchdog has to be properly closed with magic
 390  * close character otherwise the machine will be rebooted!
 391  *
 392  * Don't use err() or exit() here!
 393  */
 394 static int set_watchdog(struct wd_control *ctl, struct wd_device *wd)
 395 {
 396         int fd;
 397         sigset_t sigs, oldsigs;
 398         int rc = 0;
 399
 400         assert(wd);
 401         assert(wd->devpath);
 402         assert(ctl);
 403
 404         if (!ctl->set_timeout && !ctl->set_timeout)
 405                 goto sysfs_only;
 406
 407         sigemptyset(&oldsigs);
 408         sigfillset(&sigs);
 409         sigprocmask(SIG_BLOCK, &sigs, &oldsigs);
 410
 411         fd = open(wd->devpath, O_WRONLY|O_CLOEXEC);
 412
 413         if (fd < 0) {
 414                 if (errno == EBUSY)
 415                         warnx(_("%s: watchdog already in use, terminating."),
 416                                         wd->devpath);
 417                 warn(_("cannot open %s"), wd->devpath);
 418                 return -1;
 419         }
 420
 421         for (;;) {
 422                 /* We just opened this to query the state, not to arm
 423                  * it hence use the magic close character */
 424                 static const char v = 'V';
 425
 426                 if (write(fd, &v, 1) >= 0)
 427                         break;
 428                 if (errno != EINTR) {
 429                         warn(_("%s: failed to disarm watchdog"), wd->devpath);
 430                         break;
 431                 }
 432                 /* Let's try hard, since if we don't get this right
 433                  * the machine might end up rebooting. */
 434         }
 435
 436         if (ctl->set_timeout) {
 437                 if (ioctl(fd, WDIOC_SETTIMEOUT, &ctl->timeout) != 0) {
 438                         rc += errno;
 439                         warn(_("cannot set timeout for %s"), wd->devpath);
 440                 } else
 441                         printf(P_("Timeout has been set to %d second.\n",
 442                                   "Timeout has been set to %d seconds.\n",
 443                                   ctl->timeout), ctl->timeout);
 444         }
 445
 446         if (ctl->set_pretimeout) {
 447                 if (ioctl(fd, WDIOC_SETPRETIMEOUT, &ctl->pretimeout) != 0) {
 448                         rc += errno;
 449                         warn(_("cannot set pretimeout for %s"), wd->devpath);
 450                 } else
 451                         printf(P_("Pre-timeout has been set to %d second.\n",
 452                                   "Pre-timeout has been set to %d seconds.\n",
 453                                   ctl->pretimeout), ctl->pretimeout);
 454         }
 455
 456         if (close(fd))
 457                 warn(_("write failed"));
 458
 459         sigprocmask(SIG_SETMASK, &oldsigs, NULL);
 460
 461 sysfs_only:
 462         if (ctl->governor) {
 463                 struct path_cxt *sys = get_sysfs(wd);
 464                 int xrc;
 465
 466                 xrc = !sys ? errno :
 467                              ul_path_write_string(sys, ctl->governor,
 468                                                 "pretimeout_governor");
 469                 if (xrc)
 470                         warn(_("cannot set pre-timeout governor"));
 471                 rc += xrc;
 472         }
 473
 474         return rc;
 475 }
 476
 477 /*
 478  * Warning: successfully opened watchdog has to be properly closed with magic
 479  * close character otherwise the machine will be rebooted!
 480  *
 481  * Don't use err() or exit() here!
 482  */
 483 static int read_watchdog_from_device(struct wd_device *wd)
 484 {
 485         int fd;
 486         sigset_t sigs, oldsigs;
 487
 488         assert(wd->devpath);
 489
 490         sigemptyset(&oldsigs);
 491         sigfillset(&sigs);
 492         sigprocmask(SIG_BLOCK, &sigs, &oldsigs);
 493
 494         fd = open(wd->devpath, O_WRONLY|O_CLOEXEC);
 495
 496         if (fd < 0)
 497                 return -errno;
 498
 499         if (ioctl(fd, WDIOC_GETSUPPORT, &wd->ident) < 0)
 500                 warn(_("%s: failed to get information about watchdog"), wd->devpath);
 501         else {
 502                 ioctl(fd, WDIOC_GETSTATUS, &wd->status);
 503                 ioctl(fd, WDIOC_GETBOOTSTATUS, &wd->bstatus);
 504
 505                 /*
 506                  * Sometimes supported options like WDIOF_CARDRESET are missing from
 507                  * ident.options, add anything set in status/bstatus to ident.options.
 508                  */
 509                 wd->ident.options |= wd->status;
 510                 wd->ident.options |= wd->bstatus;
 511
 512                 if (ioctl(fd, WDIOC_GETTIMEOUT, &wd->timeout) >= 0)
 513                         wd->has_timeout = 1;
 514                 if (ioctl(fd, WDIOC_GETPRETIMEOUT, &wd->pretimeout) >= 0)
 515                         wd->has_pretimeout = 1;
 516                 if (ioctl(fd, WDIOC_GETTIMELEFT, &wd->timeleft) >= 0)
 517                         wd->has_timeleft = 1;
 518         }
 519
 520         for (;;) {
 521                 /* We just opened this to query the state, not to arm
 522                  * it hence use the magic close character */
 523                 static const char v = 'V';
 524
 525                 if (write(fd, &v, 1) >= 0)
 526                         break;
 527                 if (errno != EINTR) {
 528                         warn(_("%s: failed to disarm watchdog"), wd->devpath);
 529                         break;
 530                 }
 531                 /* Let's try hard, since if we don't get this right
 532                  * the machine might end up rebooting. */
 533         }
 534
 535         if (close(fd))
 536                 warn(_("write failed"));
 537         sigprocmask(SIG_SETMASK, &oldsigs, NULL);
 538
 539         return 0;
 540 }
 541
 542
 543 /* Returns: <0 error, 0 success, 1 unssuported */
 544 static int read_watchdog_from_sysfs(struct wd_device *wd)
 545 {
 546         struct path_cxt *sys;
 547
 548         sys = get_sysfs(wd);
 549         if (!sys)
 550                 return 1;
 551
 552         ul_path_read_buffer(sys, (char *) wd->ident.identity, sizeof(wd->ident.identity), "identity");
 553         ul_path_read_u32(sys, &wd->ident.firmware_version, "fw_version");
 554         ul_path_scanf(sys, "options", "%x", &wd->ident.options);
 555
 556         ul_path_scanf(sys, "status", "%x", &wd->status);
 557         ul_path_read_u32(sys, &wd->bstatus, "bootstatus");
 558
 559         if (ul_path_read_s32(sys, &wd->nowayout, "nowayout") == 0)
 560                 wd->has_nowayout = 1;
 561         if (ul_path_read_s32(sys, &wd->timeout, "timeout") == 0)
 562                 wd->has_timeout = 1;
 563         if (ul_path_read_s32(sys, &wd->pretimeout, "pretimeout") == 0)
 564                 wd->has_pretimeout = 1;
 565         if (ul_path_read_s32(sys, &wd->timeleft, "timeleft") == 0)
 566                 wd->has_timeleft = 1;
 567
 568         return 0;
 569 }
 570
 571 static int read_governors(struct wd_device *wd)
 572 {
 573         struct path_cxt *sys;
 574         FILE *f;
 575
 576         sys = get_sysfs(wd);
 577         if (!sys)
 578                 return 1;
 579
 580         f = ul_path_fopen(sys, "r", "pretimeout_available_governors");
 581         if (f) {
 582                 char *line = NULL;
 583                 size_t dummy = 0;
 584                 ssize_t sz;
 585
 586                 while ((sz = getline(&line, &dummy, f)) >= 0) {
 587                         if (rtrim_whitespace((unsigned char *) line) == 0)
 588                                 continue;
 589                         strv_consume(&wd->available_governors, line);
 590                         dummy = 0;
 591                         line = NULL;
 592                 }
 593                 free(line);
 594                 fclose(f);
 595         }
 596
 597         ul_path_read_string(sys, &wd->governor,  "pretimeout_governor");
 598         return 0;
 599 }
 600
 601 static int read_watchdog(struct wd_device *wd)
 602 {
 603         int rc = read_watchdog_from_device(wd);
 604
 605         if (rc == -EBUSY || rc == -EACCES || rc == -EPERM)
 606                 rc = read_watchdog_from_sysfs(wd);
 607
 608         if (rc) {
 609                 warn(_("cannot read information about %s"), wd->devpath);
 610                 return -1;
 611         }
 612
 613         read_governors(wd);
 614         return 0;
 615 }
 616
 617 static void show_timeouts(struct wd_device *wd)
 618 {
 619         if (wd->has_timeout)
 620                 printf(P_("%-14s %2i second\n", "%-14s %2i seconds\n", wd->timeout),
 621                           _("Timeout:"), wd->timeout);
 622         if (wd->has_timeleft)
 623                 printf(P_("%-14s %2i second\n", "%-14s %2i seconds\n", wd->timeleft),
 624                           _("Timeleft:"), wd->timeleft);
 625         if (wd->has_pretimeout)
 626                 printf(P_("%-14s %2i second\n", "%-14s %2i seconds\n", wd->pretimeout),
 627                           _("Pre-timeout:"), wd->pretimeout);
 628 }
 629
 630 static void show_governors(struct wd_device *wd)
 631 {
 632         if (wd->governor)
 633                 printf(_("%-14s %s\n"), _("Pre-timeout governor:"), wd->governor);
 634         if (wd->available_governors) {
 635                 char *tmp = strv_join(wd->available_governors, " ");
 636
 637                 if (tmp)
 638                         printf(_("%-14s %s\n"),
 639                                 _("Available pre-timeout governors:"), tmp);
 640                 free(tmp);
 641         }
 642 }
 643
 644 static void print_oneline(struct wd_control *ctl, struct wd_device *wd, uint32_t wanted)
 645 {
 646         printf("%s:", wd->devpath);
 647
 648         if (!ctl->hide_ident) {
 649                 printf(" VERSION=\"%x\"", wd->ident.firmware_version);
 650
 651                 printf(" IDENTITY=");
 652                 fputs_quoted((char *) wd->ident.identity, stdout);
 653         }
 654         if (!ctl->hide_timeouts) {
 655                 if (wd->has_timeout)
 656                         printf(" TIMEOUT=\"%i\"", wd->timeout);
 657                 if (wd->has_pretimeout)
 658                         printf(" PRETIMEOUT=\"%i\"", wd->pretimeout);
 659                 if (wd->has_timeleft)
 660                         printf(" TIMELEFT=\"%i\"", wd->timeleft);
 661         }
 662
 663         if (!ctl->hide_flags) {
 664                 size_t i;
 665                 uint32_t flags = wd->ident.options;
 666
 667                 for (i = 0; i < ARRAY_SIZE(wdflags); i++) {
 668                         const struct wdflag *fl;
 669
 670                         if ((wanted && !(wanted & wdflags[i].flag)) ||
 671                             !(flags & wdflags[i].flag))
 672                                 continue;
 673
 674                         fl= &wdflags[i];
 675
 676                         printf(" %s=\"%s\"", fl->name,
 677                                              wd->status & fl->flag ? "1" : "0");
 678                         printf(" %s_BOOT=\"%s\"", fl->name,
 679                                              wd->bstatus & fl->flag ? "1" : "0");
 680
 681                 }
 682         }
 683
 684         fputc('\n', stdout);
 685 }
 686
 687 static void print_device(struct wd_control *ctl, struct wd_device *wd, uint32_t wanted)
 688 {
 689         /* NAME=value one line output */
 690         if (ctl->show_oneline) {
 691                 print_oneline(ctl, wd, wanted);
 692                 return;
 693         }
 694
 695         /* pretty output */
 696         if (!ctl->hide_ident) {
 697                 printf("%-15s%s\n", _("Device:"), wd->devpath);
 698                 printf("%-15s%s [%s %x]\n",
 699                                 _("Identity:"),
 700                                 wd->ident.identity,
 701                                 _("version"),
 702                                 wd->ident.firmware_version);
 703         }
 704         if (!ctl->hide_timeouts)
 705                 show_timeouts(wd);
 706
 707         show_governors(wd);
 708
 709         if (!ctl->hide_flags)
 710                 show_flags(ctl, wd, wanted);
 711 }
 712
 713 int main(int argc, char *argv[])
 714 {
 715         struct wd_device wd;
 716         struct wd_control ctl = { .hide_headings = 0 };
 717         int c, res = EXIT_SUCCESS, count = 0;
 718         unsigned long wanted = 0;
 719         const char *dflt_device = NULL;
 720
 721         static const struct option long_opts[] = {
 722                 { "flags",      required_argument, NULL, 'f' },
 723                 { "flags-only", no_argument,       NULL, 'x' },
 724                 { "help",       no_argument,       NULL, 'h' },
 725                 { "noflags",    no_argument,       NULL, 'F' },
 726                 { "noheadings", no_argument,       NULL, 'n' },
 727                 { "noident",    no_argument,       NULL, 'I' },
 728                 { "notimeouts", no_argument,       NULL, 'T' },
 729                 { "settimeout", required_argument, NULL, 's' },
 730                 { "setpretimeout", required_argument, NULL, 'p' },
 731                 { "setpregovernor", required_argument, NULL, 'g' },
 732                 { "output",     required_argument, NULL, 'o' },
 733                 { "oneline",    no_argument,       NULL, 'O' },
 734                 { "raw",        no_argument,       NULL, 'r' },
 735                 { "version",    no_argument,       NULL, 'V' },
 736                 { NULL, 0, NULL, 0 }
 737         };
 738
 739         static const ul_excl_t excl[] = {       /* rows and cols in ASCII order */
 740                 { 'F','f' },                    /* noflags,flags*/
 741                 { 0 }
 742         };
 743         int excl_st[ARRAY_SIZE(excl)] = UL_EXCL_STATUS_INIT;
 744
 745         setlocale(LC_ALL, "");
 746         bindtextdomain(PACKAGE, LOCALEDIR);
 747         textdomain(PACKAGE);
 748         close_stdout_atexit();
 749
 750         while ((c = getopt_long(argc, argv,
 751                                 "d:f:g:hFnITp:o:s:OrVx", long_opts, NULL)) != -1) {
 752
 753                 err_exclusive_options(c, long_opts, excl, excl_st);
 754
 755                 switch(c) {
 756                 case 'o':
 757                         ncolumns = string_to_idarray(optarg,
 758                                                      columns, ARRAY_SIZE(columns),
 759                                                      column2id);
 760                         if (ncolumns < 0)
 761                                 return EXIT_FAILURE;
 762                         break;
 763                 case 's':
 764                         ctl.timeout = strtos32_or_err(optarg, _("invalid timeout argument"));
 765                         ctl.set_timeout = 1;
 766                         break;
 767                 case 'p':
 768                         ctl.pretimeout = strtos32_or_err(optarg, _("invalid pretimeout argument"));
 769                         ctl.set_pretimeout = 1;
 770                         break;
 771                 case 'f':
 772                         if (string_to_bitmask(optarg, &wanted, name2bit) != 0)
 773                                 return EXIT_FAILURE;
 774                         break;
 775                 case 'F':
 776                         ctl.hide_flags = 1;
 777                         break;
 778                 case 'g':
 779                         ctl.governor = optarg;
 780                         break;
 781                 case 'I':
 782                         ctl.hide_ident = 1;
 783                         break;
 784                 case 'T':
 785                         ctl.hide_timeouts = 1;
 786                         break;
 787                 case 'n':
 788                         ctl.hide_headings = 1;
 789                         break;
 790                 case 'r':
 791                         ctl.show_raw = 1;
 792                         break;
 793                 case 'O':
 794                         ctl.show_oneline = 1;
 795                         break;
 796                 case 'x':
 797                         ctl.hide_ident = 1;
 798                         ctl.hide_timeouts = 1;
 799                         break;
 800
 801                 case 'h':
 802                         usage();
 803                 case 'V':
 804                         print_version(EXIT_SUCCESS);
 805                 default:
 806                         errtryhelp(EXIT_FAILURE);
 807                 }
 808         }
 809
 810         if (!ncolumns) {
 811                 /* default columns */
 812                 columns[ncolumns++] = COL_FLAG;
 813                 columns[ncolumns++] = COL_DESC;
 814                 columns[ncolumns++] = COL_STATUS;
 815                 columns[ncolumns++] = COL_BSTATUS;
 816         }
 817
 818         /* Device no specified, use default. */
 819         if (optind == argc) {
 820                 dflt_device = get_default_device();
 821                 if (!dflt_device)
 822                         err(EXIT_FAILURE, _("No default device is available."));
 823         }
 824
 825         do {
 826                 int rc;
 827
 828                 memset(&wd, 0, sizeof(wd));
 829                 wd.devpath = dflt_device ? dflt_device : argv[optind++];
 830
 831                 if (count)
 832                         fputc('\n', stdout);
 833                 count++;
 834
 835                 if (want_set(&ctl)) {
 836                         rc = set_watchdog(&ctl, &wd);
 837                         if (rc) {
 838                                 res = EXIT_FAILURE;
 839                         }
 840                 }
 841
 842                 rc = read_watchdog(&wd);
 843                 if (rc) {
 844                         res = EXIT_FAILURE;
 845                         continue;
 846                 }
 847
 848                 print_device(&ctl, &wd, wanted);
 849                 ul_unref_path(wd.sysfs);
 850         } while (optind < argc);
 851
 852         return res;
 853 }