automount: make user unmounting for automount units more debuggable

Let's add an explicit log message plus an error state for automount
units, if users explicitly unmounted our autofs mount.

Prompted by: #17448

src/core/automount.c

@@ -971,6 +971,12 @@ static int automount_dispatch_io(sd_event_source *s, int fd, uint32_t events, vo
         assert(a);
         assert(fd == a->pipe_fd);
 
+        if (events & (EPOLLHUP|EPOLLERR)) {
+                log_unit_error(UNIT(a), "Got hangup/error on autofs pipe from kernel. Likely our automount point has been unmounted by someone or something else?");
+                automount_enter_dead(a, AUTOMOUNT_FAILURE_UNMOUNTED);
+                return 0;
+        }
+
         if (events != EPOLLIN) {
                 log_unit_error(UNIT(a), "Got invalid poll event %"PRIu32" on pipe (fd=%d)", events, fd);
                 goto fail;
@@ -1070,6 +1076,7 @@ static const char* const automount_result_table[_AUTOMOUNT_RESULT_MAX] = {
         [AUTOMOUNT_FAILURE_RESOURCES] = "resources",
         [AUTOMOUNT_FAILURE_START_LIMIT_HIT] = "start-limit-hit",
         [AUTOMOUNT_FAILURE_MOUNT_START_LIMIT_HIT] = "mount-start-limit-hit",
+        [AUTOMOUNT_FAILURE_UNMOUNTED] = "unmounted",
 };
 
 DEFINE_STRING_TABLE_LOOKUP(automount_result, AutomountResult);

src/core/automount.h

@@ -8,6 +8,7 @@ typedef struct Automount Automount;
 typedef enum AutomountResult {
         AUTOMOUNT_SUCCESS,
         AUTOMOUNT_FAILURE_RESOURCES,
+        AUTOMOUNT_FAILURE_UNMOUNTED,
         AUTOMOUNT_FAILURE_START_LIMIT_HIT,
         AUTOMOUNT_FAILURE_MOUNT_START_LIMIT_HIT,
         _AUTOMOUNT_RESULT_MAX,

src/core/manager.c

@@ -2938,7 +2938,7 @@ int manager_loop(Manager *m) {
 
                 watchdog_usec = manager_get_watchdog(m, WATCHDOG_RUNTIME);
                 if (timestamp_is_set(watchdog_usec))
-                        watchdog_ping();
+                        (void) watchdog_ping();
 
                 if (!ratelimit_below(&rl)) {
                         /* Yay, something is going seriously wrong, pause a little */

src/shared/watchdog.c

@@ -7,6 +7,7 @@
 #include <unistd.h>
 #include <linux/watchdog.h>
 
+#include "errno-util.h"
 #include "fd-util.h"
 #include "log.h"
 #include "string-util.h"
@@ -19,44 +20,40 @@ static usec_t watchdog_timeout = USEC_INFINITY;
 static usec_t watchdog_last_ping = USEC_INFINITY;
 
 static int update_timeout(void) {
-        int r;
-
         if (watchdog_fd < 0)
                 return 0;
-
         if (watchdog_timeout == USEC_INFINITY)
                 return 0;
-        else if (watchdog_timeout == 0) {
+
+        if (watchdog_timeout == 0) {
                 int flags;
 
                 flags = WDIOS_DISABLECARD;
-                r = ioctl(watchdog_fd, WDIOC_SETOPTIONS, &flags);
+                if (ioctl(watchdog_fd, WDIOC_SETOPTIONS, &flags) < 0)
-                if (r < 0)
                         return log_warning_errno(errno, "Failed to disable hardware watchdog: %m");
         } else {
-                int sec, flags;
                 char buf[FORMAT_TIMESPAN_MAX];
+                int sec, flags;
+                usec_t t;
 
-                sec = (int) DIV_ROUND_UP(watchdog_timeout, USEC_PER_SEC);
+                t = DIV_ROUND_UP(watchdog_timeout, USEC_PER_SEC);
-                r = ioctl(watchdog_fd, WDIOC_SETTIMEOUT, &sec);
+                sec = (int) t >= INT_MAX ? INT_MAX : t; /* Saturate */
-                if (r < 0)
+                if (ioctl(watchdog_fd, WDIOC_SETTIMEOUT, &sec) < 0)
                         return log_warning_errno(errno, "Failed to set timeout to %is: %m", sec);
 
                 watchdog_timeout = (usec_t) sec * USEC_PER_SEC;
                 log_info("Set hardware watchdog to %s.", format_timespan(buf, sizeof(buf), watchdog_timeout, 0));
 
                 flags = WDIOS_ENABLECARD;
-                r = ioctl(watchdog_fd, WDIOC_SETOPTIONS, &flags);
+                if (ioctl(watchdog_fd, WDIOC_SETOPTIONS, &flags) < 0) {
-                if (r < 0) {
                         /* ENOTTY means the watchdog is always enabled so we're fine */
-                        log_full(errno == ENOTTY ? LOG_DEBUG : LOG_WARNING,
+                        log_full(ERRNO_IS_NOT_SUPPORTED(errno) ? LOG_DEBUG : LOG_WARNING,
                                  "Failed to enable hardware watchdog: %m");
-                        if (errno != ENOTTY)
+                        if (!ERRNO_IS_NOT_SUPPORTED(errno))
                                 return -errno;
                 }
 
-                r = ioctl(watchdog_fd, WDIOC_KEEPALIVE, 0);
+                if (ioctl(watchdog_fd, WDIOC_KEEPALIVE, 0) < 0)
-                if (r < 0)
                         return log_warning_errno(errno, "Failed to ping hardware watchdog: %m");
 
                 watchdog_last_ping = now(clock_boottime_or_monotonic());
@@ -67,19 +64,23 @@ static int update_timeout(void) {
 
 static int open_watchdog(void) {
         struct watchdog_info ident;
+        const char *fn;
 
         if (watchdog_fd >= 0)
                 return 0;
 
-        watchdog_fd = open(watchdog_device ?: "/dev/watchdog",
+        fn = watchdog_device ?: "/dev/watchdog";
-                           O_WRONLY|O_CLOEXEC);
+        watchdog_fd = open(fn, O_WRONLY|O_CLOEXEC);
         if (watchdog_fd < 0)
-                return -errno;
+                return log_debug_errno(errno, "Failed to open watchdog device %s: %m", fn);
 
-        if (ioctl(watchdog_fd, WDIOC_GETSUPPORT, &ident) >= 0)
+        if (ioctl(watchdog_fd, WDIOC_GETSUPPORT, &ident) < 0)
-                log_info("Hardware watchdog '%s', version %x",
+                log_debug_errno(errno, "Hardware watchdog %s does not support WDIOC_GETSUPPORT ioctl: %m", fn);
+        else
+                log_info("Using hardware watchdog '%s', version %x, device %s",
                          ident.identity,
-                         ident.firmware_version);
+                         ident.firmware_version,
+                         fn);
 
         return update_timeout();
 }
@@ -102,8 +103,8 @@ int watchdog_set_timeout(usec_t *usec) {
 
         watchdog_timeout = *usec;
 
-        /* If we didn't open the watchdog yet and didn't get any
+        /* If we didn't open the watchdog yet and didn't get any explicit timeout value set, don't do
-         * explicit timeout value set, don't do anything */
+         * anything */
         if (watchdog_fd < 0 && watchdog_timeout == USEC_INFINITY)
                 return 0;
 
@@ -113,13 +114,11 @@ int watchdog_set_timeout(usec_t *usec) {
                 r = update_timeout();
 
         *usec = watchdog_timeout;
-
         return r;
 }
 
 usec_t watchdog_runtime_wait(void) {
-        usec_t rtwait;
+        usec_t rtwait, ntime;
-        usec_t ntime;
 
         if (!timestamp_is_set(watchdog_timeout))
                 return USEC_INFINITY;
@@ -155,18 +154,14 @@ int watchdog_ping(void) {
                         return r;
         }
 
-        r = ioctl(watchdog_fd, WDIOC_KEEPALIVE, 0);
+        if (ioctl(watchdog_fd, WDIOC_KEEPALIVE, 0) < 0)
-        if (r < 0)
                 return log_warning_errno(errno, "Failed to ping hardware watchdog: %m");
 
         watchdog_last_ping = ntime;
-
         return 0;
 }
 
 void watchdog_close(bool disarm) {
-        int r;
-
         if (watchdog_fd < 0)
                 return;
 
@@ -175,8 +170,7 @@ void watchdog_close(bool disarm) {
 
                 /* Explicitly disarm it */
                 flags = WDIOS_DISABLECARD;
-                r = ioctl(watchdog_fd, WDIOC_SETOPTIONS, &flags);
+                if (ioctl(watchdog_fd, WDIOC_SETOPTIONS, &flags) < 0)
-                if (r < 0)
                         log_warning_errno(errno, "Failed to disable hardware watchdog: %m");
 
                 /* To be sure, use magic close logic, too */