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