src/watchdog-mux.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <unistd.h>
   4 #include <fcntl.h>
   5 #include <string.h>
   6 #include <errno.h>
   7 #include <time.h>
   8 #include <sys/ioctl.h>
   9 #include <sys/types.h>
  10 #include <sys/stat.h>
  11 #include <sys/socket.h>
  12 #include <sys/un.h>
  13 #include <sys/epoll.h>
  14 #include <signal.h>
  15 #include <sys/signalfd.h>
  16
  17 #include <linux/types.h>
  18 #include <linux/watchdog.h>
  19
  20 #include <systemd/sd-daemon.h>
  21
  22 #define WD_SOCK_PATH "/run/watchdog-mux.sock"
  23 #define WD_ACTIVE_MARKER "/run/watchdog-mux.active"
  24
  25 #define LISTEN_BACKLOG 32 /* set same value in watchdog-mux.socket */
  26
  27 #define MAX_EVENTS 10
  28
  29 #define WATCHDOG_DEV "/dev/watchdog"
  30
  31 int watchdog_fd = -1;
  32 int watchdog_timeout = 10;
  33 int client_watchdog_timeout = 60;
  34 int update_watchdog = 1;
  35
  36 typedef struct {
  37     int fd;
  38     time_t time;
  39     int magic_close;
  40 } wd_client_t;
  41
  42 #define MAX_CLIENTS 100
  43
  44 static wd_client_t client_list[MAX_CLIENTS];
  45
  46 static wd_client_t *
  47 alloc_client(int fd, time_t time)
  48 {
  49     int i;
  50
  51     for (i = 0; i < MAX_CLIENTS; i++) {
  52         if (client_list[i].fd == 0) {
  53             client_list[i].fd = fd;
  54             client_list[i].time = time;
  55             client_list[i].magic_close = 0;
  56             return &client_list[i];
  57         }
  58     }
  59
  60     return NULL;
  61 }
  62
  63 static void
  64 free_client(wd_client_t *wd_client)
  65 {
  66     if (!wd_client)
  67         return;
  68
  69     wd_client->time = 0;
  70     wd_client->fd = 0;
  71     wd_client->magic_close = 0;
  72 }
  73
  74 static int
  75 active_client_count(void)
  76 {
  77     int i, count = 0;
  78
  79     for (i = 0; i < MAX_CLIENTS; i++) {
  80         if (client_list[i].fd != 0 && client_list[i].time != 0) {
  81             count++;
  82         }
  83     }
  84
  85     return count;
  86 }
  87
  88 static void
  89 watchdog_close(void)
  90 {
  91     if (watchdog_fd != -1) {
  92         if (write(watchdog_fd, "V", 1) == -1) {
  93             perror("write magic watchdog close");
  94         }
  95         if (close(watchdog_fd) == -1) {
  96             perror("write magic watchdog close");
  97         }
  98     }
  99
 100     watchdog_fd = -1;
 101 }
 102
 103 int
 104 main(void)
 105 {
 106     struct sockaddr_un my_addr, peer_addr;
 107     socklen_t peer_addr_size;
 108     struct epoll_event ev, events[MAX_EVENTS];
 109     int socket_count, listen_sock, nfds, epollfd, sigfd;
 110     int unlink_socket = 0;
 111
 112     struct stat fs;
 113
 114     if (stat(WD_ACTIVE_MARKER, &fs) == 0) {
 115         fprintf(stderr, "watchdog active - unable to restart watchdog-mux\n");
 116         exit(EXIT_FAILURE);
 117     }
 118
 119     /* if you want to debug, set options in /lib/modprobe.d/aliases.conf
 120      * options softdog soft_noboot=1
 121      */
 122     if (stat(WATCHDOG_DEV, &fs) == -1) {
 123         system("modprobe -q softdog"); // load softdog by default
 124     }
 125
 126     if ((watchdog_fd = open(WATCHDOG_DEV, O_WRONLY)) == -1) {
 127          perror("watchdog open");
 128          exit(EXIT_FAILURE);
 129     }
 130
 131     if (ioctl(watchdog_fd, WDIOC_SETTIMEOUT, &watchdog_timeout) == -1) {
 132         perror("watchdog set timeout");
 133         watchdog_close();
 134         exit(EXIT_FAILURE);
 135     }
 136
 137     /* read and log watchdog identity */
 138     struct watchdog_info wdinfo;
 139     if (ioctl(watchdog_fd, WDIOC_GETSUPPORT, &wdinfo) == -1) {
 140         perror("read watchdog info");
 141         watchdog_close();
 142         exit(EXIT_FAILURE);
 143     }
 144
 145     wdinfo.identity[sizeof(wdinfo.identity) - 1] = 0; // just to be sure
 146     fprintf(stderr, "Watchdog driver '%s', version %x\n",
 147             wdinfo.identity, wdinfo.firmware_version);
 148
 149     socket_count = sd_listen_fds(0);
 150
 151     if (socket_count > 1) {
 152
 153         perror("too many file descriptors received.\n");
 154         goto err;
 155
 156     } else if (socket_count == 1) {
 157
 158         listen_sock = SD_LISTEN_FDS_START + 0;
 159
 160     } else {
 161
 162         unlink_socket = 1;
 163
 164         unlink(WD_SOCK_PATH);
 165
 166         listen_sock = socket(AF_UNIX, SOCK_STREAM, 0);
 167         if (listen_sock == -1) {
 168             perror("socket create");
 169             exit(EXIT_FAILURE);
 170         }
 171
 172         memset(&my_addr, 0, sizeof(struct sockaddr_un));
 173         my_addr.sun_family = AF_UNIX;
 174         strncpy(my_addr.sun_path, WD_SOCK_PATH, sizeof(my_addr.sun_path) - 1);
 175
 176         if (bind(listen_sock, (struct sockaddr *) &my_addr,
 177                  sizeof(struct sockaddr_un)) == -1) {
 178             perror("socket bind");
 179             exit(EXIT_FAILURE);
 180         }
 181
 182         if (listen(listen_sock, LISTEN_BACKLOG) == -1) {
 183             perror("socket listen");
 184             goto err;
 185         }
 186     }
 187
 188     epollfd = epoll_create(10);
 189     if (epollfd == -1) {
 190         perror("epoll_create");
 191         goto err;
 192     }
 193
 194     ev.events = EPOLLIN;
 195     ev.data.ptr = alloc_client(listen_sock, 0);
 196     if (epoll_ctl(epollfd, EPOLL_CTL_ADD, listen_sock, &ev) == -1) {
 197         perror("epoll_ctl add listen_sock");
 198         goto err;
 199     }
 200
 201     sigset_t mask;
 202     sigemptyset(&mask);
 203     sigaddset(&mask, SIGINT);
 204     sigaddset(&mask, SIGTERM);
 205     sigaddset(&mask, SIGHUP);
 206
 207     sigprocmask(SIG_BLOCK, &mask, NULL);
 208
 209     if ((sigfd = signalfd(-1, &mask, SFD_NONBLOCK)) < 0) {
 210         perror("unable to open signalfd");
 211         goto err;
 212     }
 213
 214     ev.events = EPOLLIN;
 215     ev.data.ptr = alloc_client(sigfd, 0);
 216     if (epoll_ctl(epollfd, EPOLL_CTL_ADD, sigfd, &ev) == -1) {
 217         perror("epoll_ctl add sigfd");
 218         goto err;
 219     }
 220
 221     for (;;) {
 222         nfds = epoll_wait(epollfd, events, MAX_EVENTS, 1000);
 223         if (nfds == -1) {
 224             if (errno == EINTR)
 225                 continue;
 226
 227             perror("epoll_pwait");
 228             goto err;
 229         }
 230
 231         if (nfds == 0) { // timeout
 232
 233             // check for timeouts
 234             if (update_watchdog) {
 235                 int i;
 236                 time_t ctime = time(NULL);
 237                 for (i = 0; i < MAX_CLIENTS; i++) {
 238                     if (client_list[i].fd != 0 && client_list[i].time != 0 &&
 239                         ((ctime - client_list[i].time) > client_watchdog_timeout)) {
 240                         update_watchdog = 0;
 241                         fprintf(stderr, "client watchdog expired - disable watchdog updates\n");
 242                     }
 243                 }
 244             }
 245
 246             if (update_watchdog) {
 247                 if (ioctl(watchdog_fd, WDIOC_KEEPALIVE, 0) == -1) {
 248                     perror("watchdog update failed");
 249                 }
 250             }
 251
 252             continue;
 253         }
 254
 255         if (!update_watchdog)
 256             break;
 257
 258         int terminate = 0;
 259
 260         int n;
 261         for (n = 0; n < nfds; ++n) {
 262             wd_client_t *wd_client = events[n].data.ptr;
 263             if (wd_client->fd == listen_sock) {
 264                 int conn_sock = accept(listen_sock, (struct sockaddr *) &peer_addr, &peer_addr_size);
 265                 if (conn_sock == -1) {
 266                     perror("accept");
 267                     goto err; // fixme
 268                 }
 269                 if (fcntl(conn_sock, F_SETFL, O_NONBLOCK) == -1) {
 270                     perror("setnonblocking");
 271                     goto err; // fixme
 272                 }
 273
 274                 wd_client_t *new_client = alloc_client(conn_sock, time(NULL));
 275                 if (new_client == NULL) {
 276                     fprintf(stderr, "unable to alloc wd_client structure\n");
 277                     goto err; // fixme;
 278                 }
 279
 280                 mkdir(WD_ACTIVE_MARKER, 0600);
 281
 282                 ev.events = EPOLLIN;
 283                 ev.data.ptr = new_client;
 284                 if (epoll_ctl(epollfd, EPOLL_CTL_ADD, conn_sock, &ev) == -1) {
 285                     perror("epoll_ctl: add conn_sock");
 286                     goto err; // fixme
 287                 }
 288             } else if (wd_client->fd == sigfd) {
 289
 290                 /* signal handling */
 291
 292                 int rv = 0;
 293                 struct signalfd_siginfo si;
 294
 295                 if ((rv = read(sigfd, &si, sizeof(si))) && rv >= 0) {
 296                     if (si.ssi_signo == SIGHUP) {
 297                         perror("got SIGHUP - ignored");
 298                     } else {
 299                         terminate = 1;
 300                         fprintf(stderr, "got terminate request\n");
 301                     }
 302                 }
 303
 304             } else {
 305                 char buf[4096];
 306                 int cfd = wd_client->fd;
 307
 308                 ssize_t bytes = read(cfd, buf, sizeof(buf));
 309                 if (bytes == -1) {
 310                     perror("read");
 311                     goto err; // fixme
 312                 } else if (bytes > 0) {
 313                     int i;
 314                     for (i = 0; i < bytes; i++) {
 315                         if (buf[i] == 'V') {
 316                             wd_client->magic_close = 1;
 317                         } else {
 318                             wd_client->magic_close = 0;
 319                         }
 320                     }
 321                     wd_client->time = time(NULL);
 322                 } else {
 323                     if (events[n].events & EPOLLHUP || events[n].events & EPOLLERR) {
 324                         //printf("GOT %016x event\n", events[n].events);
 325                         if (epoll_ctl(epollfd, EPOLL_CTL_DEL, cfd, NULL) == -1) {
 326                             perror("epoll_ctl: del conn_sock");
 327                             goto err; // fixme
 328                         }
 329                         if (close(cfd) == -1) {
 330                             perror("close conn_sock");
 331                             goto err; // fixme
 332                         }
 333
 334                         if (!wd_client->magic_close) {
 335                             fprintf(stderr, "client did not stop watchdog - disable watchdog updates\n");
 336                             update_watchdog = 0;
 337                         } else {
 338                             free_client(wd_client);
 339                         }
 340
 341                         if (!active_client_count()) {
 342                             rmdir(WD_ACTIVE_MARKER);
 343                         }
 344                     }
 345                 }
 346             }
 347         }
 348         if (terminate)
 349             break;
 350     }
 351
 352     int active_count = active_client_count();
 353     if (active_count > 0) {
 354         fprintf(stderr, "exit watchdog-mux with active connections\n");
 355     } else {
 356         fprintf(stderr, "clean exit\n");
 357         watchdog_close();
 358     }
 359
 360     if (unlink_socket)
 361             unlink(WD_SOCK_PATH);
 362
 363     exit(EXIT_SUCCESS);
 364
 365 err:
 366     if (unlink_socket)
 367             unlink(WD_SOCK_PATH);
 368
 369     exit(EXIT_FAILURE);
 370 }