Merge pull request #20500 from poettering/import-tweaks

a few minor tweaks/bugfixlets to importd backends
Merge pull request #20499 from poettering/align-to-tweak
2026-03-26 00:34:53 +01:00 · 2021-08-21 12:50:22 +09:00 · 2021-08-21 12:50:07 +09:00 · 2021-08-21 06:45:58 +09:00 · 2021-08-21 06:43:49 +09:00 · 2021-08-21 06:40:25 +09:00
32 changed files with 546 additions and 438 deletions
--- a/man/hwdb-usb-device.c
+++ b/man/hwdb-usb-device.c
@ -3,13 +3,13 @@
 #include <sd-hwdb.h>

 int print_usb_properties(uint16_t vid, uint16_t pid) {
-  char match[15];
+  char match[STRLEN("usb:vp") + DECIMAL_STR_MAX(uint16_t) * 2];
  sd_hwdb *hwdb;
  const char *key, *value;
  int r;

  /* Match this USB vendor and product ID combination */
-  snprintf(match, sizeof match, "usb:v%04Xp%04X", vid, pid);
+  xsprintf(match, "usb:v%04Xp%04X", vid, pid);

  r = sd_hwdb_new(&hwdb);
  if (r < 0)
--- a/man/systemd.link.xml
+++ b/man/systemd.link.xml
@ -662,49 +662,56 @@
      <varlistentry>
        <term><varname>ReceiveChecksumOffload=</varname></term>
        <listitem>
-          <para>Takes a boolean. If set to true, the hardware offload for checksumming of ingress
+          <para>Takes a boolean. If set to true, hardware offload for checksumming of ingress
          network packets is enabled. When unset, the kernel's default will be used.</para>
        </listitem>
      </varlistentry>
      <varlistentry>
        <term><varname>TransmitChecksumOffload=</varname></term>
        <listitem>
-          <para>Takes a boolean. If set to true, the hardware offload for checksumming of egress
+          <para>Takes a boolean. If set to true, hardware offload for checksumming of egress
          network packets is enabled. When unset, the kernel's default will be used.</para>
        </listitem>
      </varlistentry>
      <varlistentry>
        <term><varname>TCPSegmentationOffload=</varname></term>
        <listitem>
-          <para>Takes a boolean. If set to true, the TCP Segmentation Offload (TSO) is enabled.
+          <para>Takes a boolean. If set to true, TCP Segmentation Offload (TSO) is enabled.
          When unset, the kernel's default will be used.</para>
        </listitem>
      </varlistentry>
       <varlistentry>
      <term><varname>TCP6SegmentationOffload=</varname></term>
        <listitem>
-          <para>Takes a boolean. If set to true, the TCP6 Segmentation Offload (tx-tcp6-segmentation) is enabled.
+          <para>Takes a boolean. If set to true, TCP6 Segmentation Offload (tx-tcp6-segmentation) is enabled.
          When unset, the kernel's default will be used.</para>
        </listitem>
      </varlistentry>
      <varlistentry>
        <term><varname>GenericSegmentationOffload=</varname></term>
        <listitem>
-          <para>Takes a boolean. If set to true, the Generic Segmentation Offload (GSO) is enabled.
+          <para>Takes a boolean. If set to true, Generic Segmentation Offload (GSO) is enabled.
          When unset, the kernel's default will be used.</para>
        </listitem>
      </varlistentry>
      <varlistentry>
        <term><varname>GenericReceiveOffload=</varname></term>
        <listitem>
-          <para>Takes a boolean. If set to true, the Generic Receive Offload (GRO) is enabled.
+          <para>Takes a boolean. If set to true, Generic Receive Offload (GRO) is enabled.
          When unset, the kernel's default will be used.</para>
        </listitem>
      </varlistentry>
+      <varlistentry>
+        <term><varname>GenericReceiveOffloadHardware=</varname></term>
+        <listitem>
+          <para>Takes a boolean. If set to true, hardware accelerated Generic Receive Offload (GRO) is
+          enabled. When unset, the kernel's default will be used.</para>
+        </listitem>
+      </varlistentry>
      <varlistentry>
        <term><varname>LargeReceiveOffload=</varname></term>
        <listitem>
-          <para>Takes a boolean. If set to true, the Large Receive Offload (LRO) is enabled.
+          <para>Takes a boolean. If set to true, Large Receive Offload (LRO) is enabled.
          When unset, the kernel's default will be used.</para>
        </listitem>
      </varlistentry>
@ -736,7 +743,7 @@
      <varlistentry>
        <term><varname>RxFlowControl=</varname></term>
        <listitem>
-          <para>Takes a boolean. When set, enables the receive flow control, also known as the ethernet
+          <para>Takes a boolean. When set, enables receive flow control, also known as the ethernet
          receive PAUSE message (generate and send ethernet PAUSE frames). When unset, the kernel's
          default will be used.</para>
        </listitem>
@ -744,7 +751,7 @@
      <varlistentry>
        <term><varname>TxFlowControl=</varname></term>
        <listitem>
-          <para>Takes a boolean. When set, enables the transmit flow control, also known as the ethernet
+          <para>Takes a boolean. When set, enables transmit flow control, also known as the ethernet
          transmit PAUSE message (respond to received ethernet PAUSE frames). When unset, the kernel's
          default will be used.</para>
        </listitem>
@ -752,7 +759,7 @@
      <varlistentry>
        <term><varname>AutoNegotiationFlowControl=</varname></term>
        <listitem>
-          <para>Takes a boolean. When set, the auto negotiation enables the interface to exchange state
+          <para>Takes a boolean. When set, auto negotiation enables the interface to exchange state
          advertisements with the connected peer so that the two devices can agree on the ethernet
          PAUSE configuration. When unset, the kernel's default will be used.</para>
        </listitem>
--- a/src/basic/format-util.c
+++ b/src/basic/format-util.c
@ -15,9 +15,9 @@ char *format_ifname_full(int ifindex, char buf[static IF_NAMESIZE + 1], FormatIf
                return NULL;

        if (FLAGS_SET(flag, FORMAT_IFNAME_IFINDEX_WITH_PERCENT))
-                snprintf(buf, IF_NAMESIZE + 1, "%%%d", ifindex);
+                assert(snprintf_ok(buf, IF_NAMESIZE + 1, "%%%d", ifindex));
        else
-                snprintf(buf, IF_NAMESIZE + 1, "%d", ifindex);
+                assert(snprintf_ok(buf, IF_NAMESIZE + 1, "%d", ifindex));

        return buf;
 }
@ -56,7 +56,7 @@ char *format_bytes_full(char *buf, size_t l, uint64_t t, FormatBytesFlag flag) {
        for (size_t i = 0; i < n; i++)
                if (t >= table[i].factor) {
                        if (flag & FORMAT_BYTES_BELOW_POINT) {
-                                snprintf(buf, l,
+                                (void) snprintf(buf, l,
                                                "%" PRIu64 ".%" PRIu64 "%s",
                                                t / table[i].factor,
                                                i != n - 1 ?
@ -64,7 +64,7 @@ char *format_bytes_full(char *buf, size_t l, uint64_t t, FormatBytesFlag flag) {
                                                (t * UINT64_C(10) / table[i].factor) % UINT64_C(10),
                                                table[i].suffix);
                        } else
-                                snprintf(buf, l,
+                                (void) snprintf(buf, l,
                                                "%" PRIu64 "%s",
                                                t / table[i].factor,
                                                table[i].suffix);
@ -72,7 +72,7 @@ char *format_bytes_full(char *buf, size_t l, uint64_t t, FormatBytesFlag flag) {
                        goto finish;
                }

-        snprintf(buf, l, "%" PRIu64 "%s", t, flag & FORMAT_BYTES_TRAILING_B ? "B" : "");
+        (void) snprintf(buf, l, "%" PRIu64 "%s", t, flag & FORMAT_BYTES_TRAILING_B ? "B" : "");

 finish:
        buf[l-1] = 0;
--- a/src/basic/macro.h
+++ b/src/basic/macro.h
@ -146,6 +146,20 @@
 #define ALIGN8_PTR(p) ((void*) ALIGN8((unsigned long) (p)))

 static inline size_t ALIGN_TO(size_t l, size_t ali) {
+        /* Check that alignment is exponent of 2 */
+#if SIZE_MAX == UINT_MAX
+        assert(__builtin_popcount(ali) == 1);
+#elif SIZE_MAX == ULONG_MAX
+        assert(__builtin_popcountl(ali) == 1);
+#elif SIZE_MAX == ULONGLONG_MAX
+        assert(__builtin_popcountll(ali) == 1);
+#else
+#error "Unexpected size_t"
+#endif
+
+        if (l > SIZE_MAX - (ali - 1))
+                return SIZE_MAX; /* indicate overflow */
+
        return ((l + ali - 1) & ~(ali - 1));
 }

--- a/src/basic/time-util.c
+++ b/src/basic/time-util.c
@ -433,7 +433,7 @@ char *format_timestamp_relative(char *buf, size_t l, usec_t t) {
                usec_t years = d / USEC_PER_YEAR;
                usec_t months = (d % USEC_PER_YEAR) / USEC_PER_MONTH;

-                snprintf(buf, l, USEC_FMT " %s " USEC_FMT " %s %s",
+                (void) snprintf(buf, l, USEC_FMT " %s " USEC_FMT " %s %s",
                                years,
                                years == 1 ? "year" : "years",
                                months,
@ -443,7 +443,7 @@ char *format_timestamp_relative(char *buf, size_t l, usec_t t) {
                usec_t months = d / USEC_PER_MONTH;
                usec_t days = (d % USEC_PER_MONTH) / USEC_PER_DAY;

-                snprintf(buf, l, USEC_FMT " %s " USEC_FMT " %s %s",
+                (void) snprintf(buf, l, USEC_FMT " %s " USEC_FMT " %s %s",
                                months,
                                months == 1 ? "month" : "months",
                                days,
@ -453,42 +453,42 @@ char *format_timestamp_relative(char *buf, size_t l, usec_t t) {
                usec_t weeks = d / USEC_PER_WEEK;
                usec_t days = (d % USEC_PER_WEEK) / USEC_PER_DAY;

-                snprintf(buf, l, USEC_FMT " %s " USEC_FMT " %s %s",
+                (void) snprintf(buf, l, USEC_FMT " %s " USEC_FMT " %s %s",
                                weeks,
                                weeks == 1 ? "week" : "weeks",
                                days,
                                days == 1 ? "day" : "days",
                                s);
        } else if (d >= 2*USEC_PER_DAY)
-                snprintf(buf, l, USEC_FMT " days %s", d / USEC_PER_DAY, s);
+                (void) snprintf(buf, l, USEC_FMT " days %s", d / USEC_PER_DAY, s);
        else if (d >= 25*USEC_PER_HOUR)
-                snprintf(buf, l, "1 day " USEC_FMT "h %s",
+                (void) snprintf(buf, l, "1 day " USEC_FMT "h %s",
                                (d - USEC_PER_DAY) / USEC_PER_HOUR, s);
        else if (d >= 6*USEC_PER_HOUR)
-                snprintf(buf, l, USEC_FMT "h %s",
+                (void) snprintf(buf, l, USEC_FMT "h %s",
                                d / USEC_PER_HOUR, s);
        else if (d >= USEC_PER_HOUR)
-                snprintf(buf, l, USEC_FMT "h " USEC_FMT "min %s",
+                (void) snprintf(buf, l, USEC_FMT "h " USEC_FMT "min %s",
                                d / USEC_PER_HOUR,
                                (d % USEC_PER_HOUR) / USEC_PER_MINUTE, s);
        else if (d >= 5*USEC_PER_MINUTE)
-                snprintf(buf, l, USEC_FMT "min %s",
+                (void) snprintf(buf, l, USEC_FMT "min %s",
                                d / USEC_PER_MINUTE, s);
        else if (d >= USEC_PER_MINUTE)
-                snprintf(buf, l, USEC_FMT "min " USEC_FMT "s %s",
+                (void) snprintf(buf, l, USEC_FMT "min " USEC_FMT "s %s",
                                d / USEC_PER_MINUTE,
                                (d % USEC_PER_MINUTE) / USEC_PER_SEC, s);
        else if (d >= USEC_PER_SEC)
-                snprintf(buf, l, USEC_FMT "s %s",
+                (void) snprintf(buf, l, USEC_FMT "s %s",
                                d / USEC_PER_SEC, s);
        else if (d >= USEC_PER_MSEC)
-                snprintf(buf, l, USEC_FMT "ms %s",
+                (void) snprintf(buf, l, USEC_FMT "ms %s",
                                d / USEC_PER_MSEC, s);
        else if (d > 0)
-                snprintf(buf, l, USEC_FMT"us %s",
+                (void) snprintf(buf, l, USEC_FMT"us %s",
                                d, s);
        else
-                snprintf(buf, l, "now");
+                (void) snprintf(buf, l, "now");

        buf[l-1] = 0;
        return buf;
--- a/src/cgtop/cgtop.c
+++ b/src/cgtop/cgtop.c
@ -95,7 +95,7 @@ static Group *group_free(Group *g) {

 static const char *maybe_format_timespan(char *buf, size_t l, usec_t t, usec_t accuracy) {
        if (arg_raw) {
-               snprintf(buf, l, USEC_FMT, t);
+               (void) snprintf(buf, l, USEC_FMT, t);
               return buf;
        }
        return format_timespan(buf, l, t, accuracy);
@ -109,7 +109,7 @@ static const char *maybe_format_bytes(char *buf, size_t l, bool is_valid, uint64
        if (!is_valid)
                return "-";
        if (arg_raw) {
-                snprintf(buf, l, "%" PRIu64, t);
+                (void) snprintf(buf, l, "%" PRIu64, t);
                return buf;
        }
        return format_bytes(buf, l, t);
--- a/src/core/cgroup.c
+++ b/src/core/cgroup.c
@ -375,11 +375,11 @@ static char *format_cgroup_memory_limit_comparison(char *buf, size_t l, Unit *u,
        }

        if (r < 0) {
-                snprintf(buf, l, " (error getting kernel value: %s)", strerror_safe(r));
+                (void) snprintf(buf, l, " (error getting kernel value: %s)", strerror_safe(r));
                return buf;
        }

-        snprintf(buf, l, " (different value in kernel: %" PRIu64 ")", kval);
+        (void) snprintf(buf, l, " (different value in kernel: %" PRIu64 ")", kval);

        return buf;
 }
--- a/src/core/selinux-access.c
+++ b/src/core/selinux-access.c
@ -57,7 +57,7 @@ static int audit_callback(
        if (sd_bus_creds_get_egid(audit->creds, &gid) >= 0)
                xsprintf(gid_buf, GID_FMT, gid);

-        snprintf(msgbuf, msgbufsize,
+        (void) snprintf(msgbuf, msgbufsize,
                        "auid=%s uid=%s gid=%s%s%s%s%s%s%s",
                        login_uid_buf, uid_buf, gid_buf,
                        audit->path ? " path=\"" : "", strempty(audit->path), audit->path ? "\"" : "",
--- a/src/import/curl-util.c
+++ b/src/import/curl-util.c
@ -256,6 +256,9 @@ int curl_glue_make(CURL **ret, const char *url, void *userdata) {
        if (curl_easy_setopt(c, CURLOPT_LOW_SPEED_LIMIT, 30L) != CURLE_OK)
                return -EIO;

+        if (curl_easy_setopt(c, CURLOPT_PROTOCOLS, CURLPROTO_HTTP|CURLPROTO_HTTPS|CURLPROTO_FILE) != CURLE_OK)
+                return -EIO;
+
        *ret = TAKE_PTR(c);
        return 0;
 }
--- a/src/import/import-fs.c
+++ b/src/import/import-fs.c
@ -185,10 +185,11 @@ static int import_fs(int argc, char *argv[], void *userdata) {
                if (r < 0)
                        return log_oom();

-                (void) mkdir_parents_label(temp_path, 0700);
                dest = temp_path;
        }

+        (void) mkdir_parents_label(dest, 0700);
+
        progress.limit = (RateLimit) { 200*USEC_PER_MSEC, 1 };

        {
--- a/src/import/import-raw.c
+++ b/src/import/import-raw.c
@ -9,6 +9,7 @@
 #include "btrfs-util.h"
 #include "copy.h"
 #include "fd-util.h"
+#include "format-util.h"
 #include "fs-util.h"
 #include "hostname-util.h"
 #include "import-common.h"
@ -248,6 +249,8 @@ static int raw_import_finish(RawImport *i) {

        i->temp_path = mfree(i->temp_path);

+        log_info("Wrote %s.", FORMAT_BYTES(i->written_uncompressed));
+
        return 0;
 }

@ -319,6 +322,9 @@ static int raw_import_try_reflink(RawImport *i) {
        if (i->compress.type != IMPORT_COMPRESS_UNCOMPRESSED)
                return 0;

+        if (i->offset != UINT64_MAX || i->size_max != UINT64_MAX)
+                return 0;
+
        if (!S_ISREG(i->input_stat.st_mode) || !S_ISREG(i->output_stat.st_mode))
                return 0;

@ -365,7 +371,7 @@ static int raw_import_write(const void *p, size_t sz, void *userdata) {
        }

        /* Generate sparse file if we created/truncated the file */
-        if (S_ISREG(i->output_stat.st_mode)) {
+        if (S_ISREG(i->output_stat.st_mode) && i->offset == UINT64_MAX) {
                ssize_t n;

                n = sparse_write(i->output_fd, p, sz, 64);
--- a/src/import/importd.c
+++ b/src/import/importd.c
@ -928,7 +928,7 @@ static int method_pull_tar_or_raw(sd_bus_message *msg, void *userdata, sd_bus_er
        if (r < 0)
                return r;

-        if (!http_url_is_valid(remote))
+        if (!http_url_is_valid(remote) && !file_url_is_valid(remote))
                return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
                                         "URL %s is invalid", remote);

--- a/src/import/pull-job.c
+++ b/src/import/pull-job.c
@ -117,7 +117,7 @@ static int pull_job_restart(PullJob *j, const char *new_url) {
 void pull_job_curl_on_finished(CurlGlue *g, CURL *curl, CURLcode result) {
        PullJob *j = NULL;
        CURLcode code;
-        long status;
+        long protocol;
        int r;

        if (curl_easy_getinfo(curl, CURLINFO_PRIVATE, (char **)&j) != CURLE_OK)
@ -131,11 +131,22 @@ void pull_job_curl_on_finished(CurlGlue *g, CURL *curl, CURLcode result) {
                goto finish;
        }

+        code = curl_easy_getinfo(curl, CURLINFO_PROTOCOL, &protocol);
+        if (code != CURLE_OK) {
+                r = log_error_errno(SYNTHETIC_ERRNO(EIO), "Failed to retrieve response code: %s", curl_easy_strerror(code));
+                goto finish;
+        }
+
+        if (IN_SET(protocol, CURLPROTO_HTTP, CURLPROTO_HTTPS)) {
+                long status;
+
                code = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &status);
                if (code != CURLE_OK) {
                        r = log_error_errno(SYNTHETIC_ERRNO(EIO), "Failed to retrieve response code: %s", curl_easy_strerror(code));
                        goto finish;
-        } else if (status == 304) {
+                }
+
+                if (status == 304) {
                        log_info("Image already downloaded. Skipping download.");
                        j->etag_exists = true;
                        r = 0;
@ -176,6 +187,7 @@ void pull_job_curl_on_finished(CurlGlue *g, CURL *curl, CURLcode result) {
                        r = log_error_errno(SYNTHETIC_ERRNO(EIO), "HTTP request to %s finished with unexpected code %li.", j->url, status);
                        goto finish;
                }
+        }

        if (j->state != PULL_JOB_RUNNING) {
                r = log_error_errno(SYNTHETIC_ERRNO(EIO), "Premature connection termination.");
@ -260,6 +272,8 @@ void pull_job_curl_on_finished(CurlGlue *g, CURL *curl, CURLcode result) {
                }
        }

+        log_info("Acquired %s.", FORMAT_BYTES(j->written_uncompressed));
+
        r = 0;

 finish:
@ -292,7 +306,7 @@ static int pull_job_write_uncompressed(const void *p, size_t sz, void *userdata)

        if (j->disk_fd >= 0) {

-                if (S_ISREG(j->disk_stat.st_mode)) {
+                if (S_ISREG(j->disk_stat.st_mode) && j->offset == UINT64_MAX) {
                        ssize_t n;

                        n = sparse_write(j->disk_fd, p, sz, 64);
--- a/src/import/pull-raw.c
+++ b/src/import/pull-raw.c
@ -835,7 +835,7 @@ int raw_pull_start(
        assert(!(flags & (PULL_SETTINGS|PULL_ROOTHASH|PULL_ROOTHASH_SIGNATURE|PULL_VERITY)) || !(flags & PULL_DIRECT));
        assert(!(flags & (PULL_SETTINGS|PULL_ROOTHASH|PULL_ROOTHASH_SIGNATURE|PULL_VERITY)) || !checksum);

-        if (!http_url_is_valid(url))
+        if (!http_url_is_valid(url) && !file_url_is_valid(url))
                return -EINVAL;

        if (local && !pull_validate_local(local, flags))
--- a/src/import/pull-tar.c
+++ b/src/import/pull-tar.c
@ -597,7 +597,7 @@ int tar_pull_start(
        assert(!(flags & PULL_SETTINGS) || !(flags & PULL_DIRECT));
        assert(!(flags & PULL_SETTINGS) || !checksum);

-        if (!http_url_is_valid(url))
+        if (!http_url_is_valid(url) && !file_url_is_valid(url))
                return -EINVAL;

        if (local && !pull_validate_local(local, flags))
--- a/src/import/pull.c
+++ b/src/import/pull.c
@ -110,7 +110,7 @@ static int pull_tar(int argc, char *argv[], void *userdata) {
        int r;

        url = argv[1];
-        if (!http_url_is_valid(url))
+        if (!http_url_is_valid(url) && !file_url_is_valid(url))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "URL '%s' is not valid.", url);

        if (argc >= 3)
@ -183,7 +183,7 @@ static int pull_raw(int argc, char *argv[], void *userdata) {
        int r;

        url = argv[1];
-        if (!http_url_is_valid(url))
+        if (!http_url_is_valid(url) && !file_url_is_valid(url))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "URL '%s' is not valid.", url);

        if (argc >= 3)
--- a/src/libsystemd/sd-bus/bus-match.c
+++ b/src/libsystemd/sd-bus/bus-match.c
@ -997,20 +997,16 @@ const char* bus_match_node_type_to_string(enum bus_match_node_type t, char buf[]
                return "path_namespace";

        case BUS_MATCH_ARG ... BUS_MATCH_ARG_LAST:
-                snprintf(buf, l, "arg%i", t - BUS_MATCH_ARG);
-                return buf;
+                return snprintf_ok(buf, l, "arg%i", t - BUS_MATCH_ARG);

        case BUS_MATCH_ARG_PATH ... BUS_MATCH_ARG_PATH_LAST:
-                snprintf(buf, l, "arg%ipath", t - BUS_MATCH_ARG_PATH);
-                return buf;
+                return snprintf_ok(buf, l, "arg%ipath", t - BUS_MATCH_ARG_PATH);

        case BUS_MATCH_ARG_NAMESPACE ... BUS_MATCH_ARG_NAMESPACE_LAST:
-                snprintf(buf, l, "arg%inamespace", t - BUS_MATCH_ARG_NAMESPACE);
-                return buf;
+                return snprintf_ok(buf, l, "arg%inamespace", t - BUS_MATCH_ARG_NAMESPACE);

        case BUS_MATCH_ARG_HAS ... BUS_MATCH_ARG_HAS_LAST:
-                snprintf(buf, l, "arg%ihas", t - BUS_MATCH_ARG_HAS);
-                return buf;
+                return snprintf_ok(buf, l, "arg%ihas", t - BUS_MATCH_ARG_HAS);

        default:
                return NULL;
--- a/src/machine/machinectl.c
+++ b/src/machine/machinectl.c
@ -2125,7 +2125,7 @@ static int pull_tar(int argc, char *argv[], void *userdata) {
        assert(bus);

        remote = argv[1];
-        if (!http_url_is_valid(remote))
+        if (!http_url_is_valid(remote) && !file_url_is_valid(remote))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "URL '%s' is not valid.", remote);

@ -2181,7 +2181,7 @@ static int pull_raw(int argc, char *argv[], void *userdata) {
        assert(bus);

        remote = argv[1];
-        if (!http_url_is_valid(remote))
+        if (!http_url_is_valid(remote) && !file_url_is_valid(remote))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "URL '%s' is not valid.", remote);

--- a/src/resolve/resolved-dns-rr.c
+++ b/src/resolve/resolved-dns-rr.c
@ -323,7 +323,7 @@ char* dns_resource_key_to_string(const DnsResourceKey *key, char *buf, size_t bu
        c = dns_class_to_string(key->class);
        t = dns_type_to_string(key->type);

-        snprintf(buf, buf_size, "%s %s%s%.0u %s%s%.0u",
+        (void) snprintf(buf, buf_size, "%s %s%s%.0u %s%s%.0u",
                        dns_resource_key_name(key),
                        strempty(c), c ? "" : "CLASS", c ? 0 : key->class,
                        strempty(t), t ? "" : "TYPE", t ? 0 : key->type);
--- a/src/shared/ethtool-util.c
+++ b/src/shared/ethtool-util.c
@ -74,6 +74,7 @@ static const char* const netdev_feature_table[_NET_DEV_FEAT_MAX] = {
        [NET_DEV_FEAT_TX]     = "tx-checksum-", /* The suffix "-" means any feature beginning with "tx-checksum-" */
        [NET_DEV_FEAT_GSO]    = "tx-generic-segmentation",
        [NET_DEV_FEAT_GRO]    = "rx-gro",
+        [NET_DEV_FEAT_GRO_HW] = "rx-gro-hw",
        [NET_DEV_FEAT_LRO]    = "rx-lro",
        [NET_DEV_FEAT_TSO]    = "tx-tcp-segmentation",
        [NET_DEV_FEAT_TSO6]   = "tx-tcp6-segmentation",
--- a/src/shared/ethtool-util.h
+++ b/src/shared/ethtool-util.h
@ -23,6 +23,7 @@ typedef enum NetDevFeature {
        NET_DEV_FEAT_TX,
        NET_DEV_FEAT_GSO,
        NET_DEV_FEAT_GRO,
+        NET_DEV_FEAT_GRO_HW,
        NET_DEV_FEAT_LRO,
        NET_DEV_FEAT_TSO,
        NET_DEV_FEAT_TSO6,
--- a/src/shared/web-util.c
+++ b/src/shared/web-util.c
@ -36,16 +36,29 @@ bool http_url_is_valid(const char *url) {
        return ascii_is_valid(p);
 }

+bool file_url_is_valid(const char *url) {
+        const char *p;
+
+        if (isempty(url))
+                return false;
+
+        p = startswith(url, "file:/");
+        if (isempty(p))
+                return false;
+
+        return ascii_is_valid(p);
+}
+
 bool documentation_url_is_valid(const char *url) {
        const char *p;

        if (isempty(url))
                return false;

-        if (http_url_is_valid(url))
+        if (http_url_is_valid(url) || file_url_is_valid(url))
                return true;

-        p = STARTSWITH_SET(url, "file:/", "info:", "man:");
+        p = STARTSWITH_SET(url, "info:", "man:");
        if (isempty(p))
                return false;

--- a/src/shared/web-util.h
+++ b/src/shared/web-util.h
@ -6,6 +6,7 @@
 #include "macro.h"

 bool http_url_is_valid(const char *url) _pure_;
+bool file_url_is_valid(const char *url) _pure_;

 bool documentation_url_is_valid(const char *url) _pure_;

--- a/src/test/meson.build
+++ b/src/test/meson.build
@ -188,6 +188,8 @@ tests += [

        [['src/test/test-util.c']],

+        [['src/test/test-macro.c']],
+
        [['src/test/test-json.c']],

        [['src/test/test-modhex.c']],
--- a/src/test/nss-test-util.c
+++ b/src/test/nss-test-util.c
@ -20,7 +20,7 @@ const char* nss_status_to_string(enum nss_status status, char *buf, size_t buf_l
        case NSS_STATUS_RETURN:
                return "NSS_STATUS_RETURN";
        default:
-                snprintf(buf, buf_len, "%i", status);
+                (void) snprintf(buf, buf_len, "%i", status);
                return buf;
        }
 };
--- a/src/test/test-macro.c
+++ b/src/test/test-macro.c
@ -0,0 +1,343 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+
+#include <stddef.h>
+
+#include "log.h"
+#include "macro.h"
+#include "tests.h"
+
+static void test_align_power2(void) {
+        unsigned long i, p2;
+
+        log_info("/* %s */", __func__);
+
+        assert_se(ALIGN_POWER2(0) == 0);
+        assert_se(ALIGN_POWER2(1) == 1);
+        assert_se(ALIGN_POWER2(2) == 2);
+        assert_se(ALIGN_POWER2(3) == 4);
+        assert_se(ALIGN_POWER2(4) == 4);
+        assert_se(ALIGN_POWER2(5) == 8);
+        assert_se(ALIGN_POWER2(6) == 8);
+        assert_se(ALIGN_POWER2(7) == 8);
+        assert_se(ALIGN_POWER2(9) == 16);
+        assert_se(ALIGN_POWER2(10) == 16);
+        assert_se(ALIGN_POWER2(11) == 16);
+        assert_se(ALIGN_POWER2(12) == 16);
+        assert_se(ALIGN_POWER2(13) == 16);
+        assert_se(ALIGN_POWER2(14) == 16);
+        assert_se(ALIGN_POWER2(15) == 16);
+        assert_se(ALIGN_POWER2(16) == 16);
+        assert_se(ALIGN_POWER2(17) == 32);
+
+        assert_se(ALIGN_POWER2(ULONG_MAX) == 0);
+        assert_se(ALIGN_POWER2(ULONG_MAX - 1) == 0);
+        assert_se(ALIGN_POWER2(ULONG_MAX - 1024) == 0);
+        assert_se(ALIGN_POWER2(ULONG_MAX / 2) == ULONG_MAX / 2 + 1);
+        assert_se(ALIGN_POWER2(ULONG_MAX + 1) == 0);
+
+        for (i = 1; i < 131071; ++i) {
+                for (p2 = 1; p2 < i; p2 <<= 1)
+                        /* empty */ ;
+
+                assert_se(ALIGN_POWER2(i) == p2);
+        }
+
+        for (i = ULONG_MAX - 1024; i < ULONG_MAX; ++i) {
+                for (p2 = 1; p2 && p2 < i; p2 <<= 1)
+                        /* empty */ ;
+
+                assert_se(ALIGN_POWER2(i) == p2);
+        }
+}
+
+static void test_max(void) {
+        static const struct {
+                int a;
+                int b[CONST_MAX(10, 100)];
+        } val1 = {
+                .a = CONST_MAX(10, 100),
+        };
+        int d = 0;
+        unsigned long x = 12345;
+        unsigned long y = 54321;
+        const char str[] = "a_string_constant";
+        const unsigned long long arr[] = {9999ULL, 10ULL, 0ULL, 3000ULL, 2000ULL, 1000ULL, 100ULL, 9999999ULL};
+        void *p = (void *)str;
+        void *q = (void *)&str[16];
+
+        log_info("/* %s */", __func__);
+
+        assert_cc(sizeof(val1.b) == sizeof(int) * 100);
+
+        /* CONST_MAX returns (void) instead of a value if the passed arguments
+         * are not of the same type or not constant expressions. */
+        assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 10)), int));
+        assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 1U)), void));
+
+        assert_se(val1.a == 100);
+        assert_se(MAX(++d, 0) == 1);
+        assert_se(d == 1);
+
+        assert_cc(MAXSIZE(char[3], uint16_t) == 3);
+        assert_cc(MAXSIZE(char[3], uint32_t) == 4);
+        assert_cc(MAXSIZE(char, long) == sizeof(long));
+
+        assert_se(MAX(-5, 5) == 5);
+        assert_se(MAX(5, 5) == 5);
+        assert_se(MAX(MAX(1, MAX(2, MAX(3, 4))), 5) == 5);
+        assert_se(MAX(MAX(1, MAX(2, MAX(3, 2))), 1) == 3);
+        assert_se(MAX(MIN(1, MIN(2, MIN(3, 4))), 5) == 5);
+        assert_se(MAX(MAX(1, MIN(2, MIN(3, 2))), 1) == 2);
+        assert_se(LESS_BY(8, 4) == 4);
+        assert_se(LESS_BY(8, 8) == 0);
+        assert_se(LESS_BY(4, 8) == 0);
+        assert_se(LESS_BY(16, LESS_BY(8, 4)) == 12);
+        assert_se(LESS_BY(4, LESS_BY(8, 4)) == 0);
+        assert_se(CMP(3, 5) == -1);
+        assert_se(CMP(5, 3) == 1);
+        assert_se(CMP(5, 5) == 0);
+        assert_se(CMP(x, y) == -1);
+        assert_se(CMP(y, x) == 1);
+        assert_se(CMP(x, x) == 0);
+        assert_se(CMP(y, y) == 0);
+        assert_se(CMP(UINT64_MAX, (uint64_t) 0) == 1);
+        assert_se(CMP((uint64_t) 0, UINT64_MAX) == -1);
+        assert_se(CMP(UINT64_MAX, UINT64_MAX) == 0);
+        assert_se(CMP(INT64_MIN, INT64_MAX) == -1);
+        assert_se(CMP(INT64_MAX, INT64_MIN) == 1);
+        assert_se(CMP(INT64_MAX, INT64_MAX) == 0);
+        assert_se(CMP(INT64_MIN, INT64_MIN) == 0);
+        assert_se(CMP(INT64_MAX, (int64_t) 0) == 1);
+        assert_se(CMP((int64_t) 0, INT64_MIN) == 1);
+        assert_se(CMP(INT64_MIN, (int64_t) 0) == -1);
+        assert_se(CMP((int64_t) 0, INT64_MAX) == -1);
+        assert_se(CMP(&str[2], &str[7]) == -1);
+        assert_se(CMP(&str[2], &str[2]) == 0);
+        assert_se(CMP(&str[7], (const char *)str) == 1);
+        assert_se(CMP(str[2], str[7]) == 1);
+        assert_se(CMP(str[7], *str) == 1);
+        assert_se(CMP((const unsigned long long *)arr, &arr[3]) == -1);
+        assert_se(CMP(*arr, arr[3]) == 1);
+        assert_se(CMP(p, q) == -1);
+        assert_se(CMP(q, p) == 1);
+        assert_se(CMP(p, p) == 0);
+        assert_se(CMP(q, q) == 0);
+        assert_se(CLAMP(-5, 0, 1) == 0);
+        assert_se(CLAMP(5, 0, 1) == 1);
+        assert_se(CLAMP(5, -10, 1) == 1);
+        assert_se(CLAMP(5, -10, 10) == 5);
+        assert_se(CLAMP(CLAMP(0, -10, 10), CLAMP(-5, 10, 20), CLAMP(100, -5, 20)) == 10);
+}
+
+#pragma GCC diagnostic push
+#ifdef __clang__
+#  pragma GCC diagnostic ignored "-Waddress-of-packed-member"
+#endif
+
+static void test_container_of(void) {
+        struct mytype {
+                uint8_t pad1[3];
+                uint64_t v1;
+                uint8_t pad2[2];
+                uint32_t v2;
+        } myval = { };
+
+        log_info("/* %s */", __func__);
+
+        assert_cc(sizeof(myval) >= 17);
+        assert_se(container_of(&myval.v1, struct mytype, v1) == &myval);
+        assert_se(container_of(&myval.v2, struct mytype, v2) == &myval);
+        assert_se(container_of(&container_of(&myval.v2,
+                                             struct mytype,
+                                             v2)->v1,
+                               struct mytype,
+                               v1) == &myval);
+}
+
+#pragma GCC diagnostic pop
+
+static void test_div_round_up(void) {
+        int div;
+
+        log_info("/* %s */", __func__);
+
+        /* basic tests */
+        assert_se(DIV_ROUND_UP(0, 8) == 0);
+        assert_se(DIV_ROUND_UP(1, 8) == 1);
+        assert_se(DIV_ROUND_UP(8, 8) == 1);
+        assert_se(DIV_ROUND_UP(12, 8) == 2);
+        assert_se(DIV_ROUND_UP(16, 8) == 2);
+
+        /* test multiple evaluation */
+        div = 0;
+        assert_se(DIV_ROUND_UP(div++, 8) == 0 && div == 1);
+        assert_se(DIV_ROUND_UP(++div, 8) == 1 && div == 2);
+        assert_se(DIV_ROUND_UP(8, div++) == 4 && div == 3);
+        assert_se(DIV_ROUND_UP(8, ++div) == 2 && div == 4);
+
+        /* overflow test with exact division */
+        assert_se(sizeof(0U) == 4);
+        assert_se(0xfffffffaU % 10U == 0U);
+        assert_se(0xfffffffaU / 10U == 429496729U);
+        assert_se(DIV_ROUND_UP(0xfffffffaU, 10U) == 429496729U);
+        assert_se((0xfffffffaU + 10U - 1U) / 10U == 0U);
+        assert_se(0xfffffffaU / 10U + !!(0xfffffffaU % 10U) == 429496729U);
+
+        /* overflow test with rounded division */
+        assert_se(0xfffffffdU % 10U == 3U);
+        assert_se(0xfffffffdU / 10U == 429496729U);
+        assert_se(DIV_ROUND_UP(0xfffffffdU, 10U) == 429496730U);
+        assert_se((0xfffffffdU + 10U - 1U) / 10U == 0U);
+        assert_se(0xfffffffdU / 10U + !!(0xfffffffdU % 10U) == 429496730U);
+}
+
+static void test_ptr_to_int(void) {
+        log_info("/* %s */", __func__);
+
+        /* Primary reason to have this test is to validate that pointers are large enough to hold entire int range */
+        assert_se(PTR_TO_INT(INT_TO_PTR(0)) == 0);
+        assert_se(PTR_TO_INT(INT_TO_PTR(1)) == 1);
+        assert_se(PTR_TO_INT(INT_TO_PTR(-1)) == -1);
+        assert_se(PTR_TO_INT(INT_TO_PTR(INT_MAX)) == INT_MAX);
+        assert_se(PTR_TO_INT(INT_TO_PTR(INT_MIN)) == INT_MIN);
+}
+
+static void test_in_set(void) {
+        log_info("/* %s */", __func__);
+
+        assert_se(IN_SET(1, 1));
+        assert_se(IN_SET(1, 1, 2, 3, 4));
+        assert_se(IN_SET(2, 1, 2, 3, 4));
+        assert_se(IN_SET(3, 1, 2, 3, 4));
+        assert_se(IN_SET(4, 1, 2, 3, 4));
+        assert_se(!IN_SET(0, 1));
+        assert_se(!IN_SET(0, 1, 2, 3, 4));
+}
+
+static void test_foreach_pointer(void) {
+        int a, b, c, *i;
+        size_t k = 0;
+
+        log_info("/* %s */", __func__);
+
+        FOREACH_POINTER(i, &a, &b, &c) {
+                switch (k) {
+
+                case 0:
+                        assert_se(i == &a);
+                        break;
+
+                case 1:
+                        assert_se(i == &b);
+                        break;
+
+                case 2:
+                        assert_se(i == &c);
+                        break;
+
+                default:
+                        assert_not_reached();
+                        break;
+                }
+
+                k++;
+        }
+
+        assert(k == 3);
+
+        FOREACH_POINTER(i, &b) {
+                assert(k == 3);
+                assert(i == &b);
+                k = 4;
+        }
+
+        assert(k == 4);
+
+        FOREACH_POINTER(i, NULL, &c, NULL, &b, NULL, &a, NULL) {
+                switch (k) {
+
+                case 4:
+                        assert_se(i == NULL);
+                        break;
+
+                case 5:
+                        assert_se(i == &c);
+                        break;
+
+                case 6:
+                        assert_se(i == NULL);
+                        break;
+
+                case 7:
+                        assert_se(i == &b);
+                        break;
+
+                case 8:
+                        assert_se(i == NULL);
+                        break;
+
+                case 9:
+                        assert_se(i == &a);
+                        break;
+
+                case 10:
+                        assert_se(i == NULL);
+                        break;
+
+                default:
+                        assert_not_reached();
+                        break;
+                }
+
+                k++;
+        }
+
+        assert(k == 11);
+}
+
+static void test_align_to(void) {
+        log_info("/* %s */", __func__);
+
+        assert_se(ALIGN_TO(0, 1) == 0);
+        assert_se(ALIGN_TO(1, 1) == 1);
+        assert_se(ALIGN_TO(2, 1) == 2);
+        assert_se(ALIGN_TO(3, 1) == 3);
+        assert_se(ALIGN_TO(4, 1) == 4);
+        assert_se(ALIGN_TO(SIZE_MAX-1, 1) == SIZE_MAX-1);
+        assert_se(ALIGN_TO(SIZE_MAX, 1) == SIZE_MAX);
+
+        assert_se(ALIGN_TO(0, 2) == 0);
+        assert_se(ALIGN_TO(1, 2) == 2);
+        assert_se(ALIGN_TO(2, 2) == 2);
+        assert_se(ALIGN_TO(3, 2) == 4);
+        assert_se(ALIGN_TO(4, 2) == 4);
+        assert_se(ALIGN_TO(SIZE_MAX-3, 2) == SIZE_MAX-3);
+        assert_se(ALIGN_TO(SIZE_MAX-2, 2) == SIZE_MAX-1);
+        assert_se(ALIGN_TO(SIZE_MAX-1, 2) == SIZE_MAX-1);
+        assert_se(ALIGN_TO(SIZE_MAX, 2) == SIZE_MAX); /* overflow */
+
+        assert_se(ALIGN_TO(0, 4) == 0);
+        assert_se(ALIGN_TO(1, 4) == 4);
+        assert_se(ALIGN_TO(2, 4) == 4);
+        assert_se(ALIGN_TO(3, 4) == 4);
+        assert_se(ALIGN_TO(4, 4) == 4);
+        assert_se(ALIGN_TO(SIZE_MAX-3, 4) == SIZE_MAX-3);
+        assert_se(ALIGN_TO(SIZE_MAX-2, 4) == SIZE_MAX); /* overflow */
+        assert_se(ALIGN_TO(SIZE_MAX-1, 4) == SIZE_MAX); /* overflow */
+        assert_se(ALIGN_TO(SIZE_MAX, 4) == SIZE_MAX);   /* overflow */
+}
+
+int main(int argc, char *argv[]) {
+        test_setup_logging(LOG_INFO);
+
+        test_align_power2();
+        test_max();
+        test_container_of();
+        test_div_round_up();
+        test_in_set();
+        test_foreach_pointer();
+        test_ptr_to_int();
+        test_align_to();
+
+        return 0;
+}
--- a/src/test/test-nss-hosts.c
+++ b/src/test/test-nss-hosts.c
@ -36,7 +36,7 @@ static const char* af_to_string(int family, char *buf, size_t buf_len) {
        if (name)
                return name;

-        snprintf(buf, buf_len, "%i", family);
+        (void) snprintf(buf, buf_len, "%i", family);
        return buf;
 }

--- a/src/test/test-util.c
+++ b/src/test/test-util.c
@ -17,191 +17,6 @@
 #include "tests.h"
 #include "util.h"

-static void test_align_power2(void) {
-        unsigned long i, p2;
-
-        log_info("/* %s */", __func__);
-
-        assert_se(ALIGN_POWER2(0) == 0);
-        assert_se(ALIGN_POWER2(1) == 1);
-        assert_se(ALIGN_POWER2(2) == 2);
-        assert_se(ALIGN_POWER2(3) == 4);
-        assert_se(ALIGN_POWER2(4) == 4);
-        assert_se(ALIGN_POWER2(5) == 8);
-        assert_se(ALIGN_POWER2(6) == 8);
-        assert_se(ALIGN_POWER2(7) == 8);
-        assert_se(ALIGN_POWER2(9) == 16);
-        assert_se(ALIGN_POWER2(10) == 16);
-        assert_se(ALIGN_POWER2(11) == 16);
-        assert_se(ALIGN_POWER2(12) == 16);
-        assert_se(ALIGN_POWER2(13) == 16);
-        assert_se(ALIGN_POWER2(14) == 16);
-        assert_se(ALIGN_POWER2(15) == 16);
-        assert_se(ALIGN_POWER2(16) == 16);
-        assert_se(ALIGN_POWER2(17) == 32);
-
-        assert_se(ALIGN_POWER2(ULONG_MAX) == 0);
-        assert_se(ALIGN_POWER2(ULONG_MAX - 1) == 0);
-        assert_se(ALIGN_POWER2(ULONG_MAX - 1024) == 0);
-        assert_se(ALIGN_POWER2(ULONG_MAX / 2) == ULONG_MAX / 2 + 1);
-        assert_se(ALIGN_POWER2(ULONG_MAX + 1) == 0);
-
-        for (i = 1; i < 131071; ++i) {
-                for (p2 = 1; p2 < i; p2 <<= 1)
-                        /* empty */ ;
-
-                assert_se(ALIGN_POWER2(i) == p2);
-        }
-
-        for (i = ULONG_MAX - 1024; i < ULONG_MAX; ++i) {
-                for (p2 = 1; p2 && p2 < i; p2 <<= 1)
-                        /* empty */ ;
-
-                assert_se(ALIGN_POWER2(i) == p2);
-        }
-}
-
-static void test_max(void) {
-        static const struct {
-                int a;
-                int b[CONST_MAX(10, 100)];
-        } val1 = {
-                .a = CONST_MAX(10, 100),
-        };
-        int d = 0;
-        unsigned long x = 12345;
-        unsigned long y = 54321;
-        const char str[] = "a_string_constant";
-        const unsigned long long arr[] = {9999ULL, 10ULL, 0ULL, 3000ULL, 2000ULL, 1000ULL, 100ULL, 9999999ULL};
-        void *p = (void *)str;
-        void *q = (void *)&str[16];
-
-        log_info("/* %s */", __func__);
-
-        assert_cc(sizeof(val1.b) == sizeof(int) * 100);
-
-        /* CONST_MAX returns (void) instead of a value if the passed arguments
-         * are not of the same type or not constant expressions. */
-        assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 10)), int));
-        assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 1U)), void));
-
-        assert_se(val1.a == 100);
-        assert_se(MAX(++d, 0) == 1);
-        assert_se(d == 1);
-
-        assert_cc(MAXSIZE(char[3], uint16_t) == 3);
-        assert_cc(MAXSIZE(char[3], uint32_t) == 4);
-        assert_cc(MAXSIZE(char, long) == sizeof(long));
-
-        assert_se(MAX(-5, 5) == 5);
-        assert_se(MAX(5, 5) == 5);
-        assert_se(MAX(MAX(1, MAX(2, MAX(3, 4))), 5) == 5);
-        assert_se(MAX(MAX(1, MAX(2, MAX(3, 2))), 1) == 3);
-        assert_se(MAX(MIN(1, MIN(2, MIN(3, 4))), 5) == 5);
-        assert_se(MAX(MAX(1, MIN(2, MIN(3, 2))), 1) == 2);
-        assert_se(LESS_BY(8, 4) == 4);
-        assert_se(LESS_BY(8, 8) == 0);
-        assert_se(LESS_BY(4, 8) == 0);
-        assert_se(LESS_BY(16, LESS_BY(8, 4)) == 12);
-        assert_se(LESS_BY(4, LESS_BY(8, 4)) == 0);
-        assert_se(CMP(3, 5) == -1);
-        assert_se(CMP(5, 3) == 1);
-        assert_se(CMP(5, 5) == 0);
-        assert_se(CMP(x, y) == -1);
-        assert_se(CMP(y, x) == 1);
-        assert_se(CMP(x, x) == 0);
-        assert_se(CMP(y, y) == 0);
-        assert_se(CMP(UINT64_MAX, (uint64_t) 0) == 1);
-        assert_se(CMP((uint64_t) 0, UINT64_MAX) == -1);
-        assert_se(CMP(UINT64_MAX, UINT64_MAX) == 0);
-        assert_se(CMP(INT64_MIN, INT64_MAX) == -1);
-        assert_se(CMP(INT64_MAX, INT64_MIN) == 1);
-        assert_se(CMP(INT64_MAX, INT64_MAX) == 0);
-        assert_se(CMP(INT64_MIN, INT64_MIN) == 0);
-        assert_se(CMP(INT64_MAX, (int64_t) 0) == 1);
-        assert_se(CMP((int64_t) 0, INT64_MIN) == 1);
-        assert_se(CMP(INT64_MIN, (int64_t) 0) == -1);
-        assert_se(CMP((int64_t) 0, INT64_MAX) == -1);
-        assert_se(CMP(&str[2], &str[7]) == -1);
-        assert_se(CMP(&str[2], &str[2]) == 0);
-        assert_se(CMP(&str[7], (const char *)str) == 1);
-        assert_se(CMP(str[2], str[7]) == 1);
-        assert_se(CMP(str[7], *str) == 1);
-        assert_se(CMP((const unsigned long long *)arr, &arr[3]) == -1);
-        assert_se(CMP(*arr, arr[3]) == 1);
-        assert_se(CMP(p, q) == -1);
-        assert_se(CMP(q, p) == 1);
-        assert_se(CMP(p, p) == 0);
-        assert_se(CMP(q, q) == 0);
-        assert_se(CLAMP(-5, 0, 1) == 0);
-        assert_se(CLAMP(5, 0, 1) == 1);
-        assert_se(CLAMP(5, -10, 1) == 1);
-        assert_se(CLAMP(5, -10, 10) == 5);
-        assert_se(CLAMP(CLAMP(0, -10, 10), CLAMP(-5, 10, 20), CLAMP(100, -5, 20)) == 10);
-}
-
-#pragma GCC diagnostic push
-#ifdef __clang__
-#  pragma GCC diagnostic ignored "-Waddress-of-packed-member"
-#endif
-
-static void test_container_of(void) {
-        struct mytype {
-                uint8_t pad1[3];
-                uint64_t v1;
-                uint8_t pad2[2];
-                uint32_t v2;
-        } myval = { };
-
-        log_info("/* %s */", __func__);
-
-        assert_cc(sizeof(myval) >= 17);
-        assert_se(container_of(&myval.v1, struct mytype, v1) == &myval);
-        assert_se(container_of(&myval.v2, struct mytype, v2) == &myval);
-        assert_se(container_of(&container_of(&myval.v2,
-                                             struct mytype,
-                                             v2)->v1,
-                               struct mytype,
-                               v1) == &myval);
-}
-
-#pragma GCC diagnostic pop
-
-static void test_div_round_up(void) {
-        int div;
-
-        log_info("/* %s */", __func__);
-
-        /* basic tests */
-        assert_se(DIV_ROUND_UP(0, 8) == 0);
-        assert_se(DIV_ROUND_UP(1, 8) == 1);
-        assert_se(DIV_ROUND_UP(8, 8) == 1);
-        assert_se(DIV_ROUND_UP(12, 8) == 2);
-        assert_se(DIV_ROUND_UP(16, 8) == 2);
-
-        /* test multiple evaluation */
-        div = 0;
-        assert_se(DIV_ROUND_UP(div++, 8) == 0 && div == 1);
-        assert_se(DIV_ROUND_UP(++div, 8) == 1 && div == 2);
-        assert_se(DIV_ROUND_UP(8, div++) == 4 && div == 3);
-        assert_se(DIV_ROUND_UP(8, ++div) == 2 && div == 4);
-
-        /* overflow test with exact division */
-        assert_se(sizeof(0U) == 4);
-        assert_se(0xfffffffaU % 10U == 0U);
-        assert_se(0xfffffffaU / 10U == 429496729U);
-        assert_se(DIV_ROUND_UP(0xfffffffaU, 10U) == 429496729U);
-        assert_se((0xfffffffaU + 10U - 1U) / 10U == 0U);
-        assert_se(0xfffffffaU / 10U + !!(0xfffffffaU % 10U) == 429496729U);
-
-        /* overflow test with rounded division */
-        assert_se(0xfffffffdU % 10U == 3U);
-        assert_se(0xfffffffdU / 10U == 429496729U);
-        assert_se(DIV_ROUND_UP(0xfffffffdU, 10U) == 429496730U);
-        assert_se((0xfffffffdU + 10U - 1U) / 10U == 0U);
-        assert_se(0xfffffffdU / 10U + !!(0xfffffffdU % 10U) == 429496730U);
-}
-
 static void test_u64log2(void) {
        log_info("/* %s */", __func__);

@ -249,18 +64,6 @@ static void test_unprotect_errno(void) {
        assert_se(errno == 4711);
 }

-static void test_in_set(void) {
-        log_info("/* %s */", __func__);
-
-        assert_se(IN_SET(1, 1));
-        assert_se(IN_SET(1, 1, 2, 3, 4));
-        assert_se(IN_SET(2, 1, 2, 3, 4));
-        assert_se(IN_SET(3, 1, 2, 3, 4));
-        assert_se(IN_SET(4, 1, 2, 3, 4));
-        assert_se(!IN_SET(0, 1));
-        assert_se(!IN_SET(0, 1, 2, 3, 4));
-}
-
 static void test_log2i(void) {
        log_info("/* %s */", __func__);

@ -409,109 +212,12 @@ static void test_system_tasks_max_scale(void) {
        assert_se(system_tasks_max_scale(UINT64_MAX/4, UINT64_MAX) == UINT64_MAX);
 }

-static void test_foreach_pointer(void) {
-        int a, b, c, *i;
-        size_t k = 0;
-
-        log_info("/* %s */", __func__);
-
-        FOREACH_POINTER(i, &a, &b, &c) {
-                switch (k) {
-
-                case 0:
-                        assert_se(i == &a);
-                        break;
-
-                case 1:
-                        assert_se(i == &b);
-                        break;
-
-                case 2:
-                        assert_se(i == &c);
-                        break;
-
-                default:
-                        assert_not_reached();
-                        break;
-                }
-
-                k++;
-        }
-
-        assert(k == 3);
-
-        FOREACH_POINTER(i, &b) {
-                assert(k == 3);
-                assert(i == &b);
-                k = 4;
-        }
-
-        assert(k == 4);
-
-        FOREACH_POINTER(i, NULL, &c, NULL, &b, NULL, &a, NULL) {
-                switch (k) {
-
-                case 4:
-                        assert_se(i == NULL);
-                        break;
-
-                case 5:
-                        assert_se(i == &c);
-                        break;
-
-                case 6:
-                        assert_se(i == NULL);
-                        break;
-
-                case 7:
-                        assert_se(i == &b);
-                        break;
-
-                case 8:
-                        assert_se(i == NULL);
-                        break;
-
-                case 9:
-                        assert_se(i == &a);
-                        break;
-
-                case 10:
-                        assert_se(i == NULL);
-                        break;
-
-                default:
-                        assert_not_reached();
-                        break;
-                }
-
-                k++;
-        }
-
-        assert(k == 11);
-}
-
-static void test_ptr_to_int(void) {
-        log_info("/* %s */", __func__);
-
-        /* Primary reason to have this test is to validate that pointers are large enough to hold entire int range */
-        assert_se(PTR_TO_INT(INT_TO_PTR(0)) == 0);
-        assert_se(PTR_TO_INT(INT_TO_PTR(1)) == 1);
-        assert_se(PTR_TO_INT(INT_TO_PTR(-1)) == -1);
-        assert_se(PTR_TO_INT(INT_TO_PTR(INT_MAX)) == INT_MAX);
-        assert_se(PTR_TO_INT(INT_TO_PTR(INT_MIN)) == INT_MIN);
-}
-
 int main(int argc, char *argv[]) {
        test_setup_logging(LOG_INFO);

-        test_align_power2();
-        test_max();
-        test_container_of();
-        test_div_round_up();
        test_u64log2();
        test_protect_errno();
        test_unprotect_errno();
-        test_in_set();
        test_log2i();
        test_eqzero();
        test_raw_clone();
@ -519,8 +225,6 @@ int main(int argc, char *argv[]) {
        test_physical_memory_scale();
        test_system_tasks_max();
        test_system_tasks_max_scale();
-        test_foreach_pointer();
-        test_ptr_to_int();

        return 0;
 }
--- a/src/udev/net/link-config-gperf.gperf
+++ b/src/udev/net/link-config-gperf.gperf
@ -57,6 +57,7 @@ Link.TCPSegmentationOffload,              config_parse_tristate,
 Link.TCP6SegmentationOffload,             config_parse_tristate,                 0,                             offsetof(LinkConfig, features[NET_DEV_FEAT_TSO6])
 Link.UDPSegmentationOffload,              config_parse_warn_compat,              DISABLED_LEGACY,               0
 Link.GenericReceiveOffload,               config_parse_tristate,                 0,                             offsetof(LinkConfig, features[NET_DEV_FEAT_GRO])
+Link.GenericReceiveOffloadHardware,       config_parse_tristate,                 0,                             offsetof(LinkConfig, features[NET_DEV_FEAT_GRO_HW])
 Link.LargeReceiveOffload,                 config_parse_tristate,                 0,                             offsetof(LinkConfig, features[NET_DEV_FEAT_LRO])
 Link.RxChannels,                          config_parse_ring_buffer_or_channel,   0,                             offsetof(LinkConfig, channels.rx)
 Link.TxChannels,                          config_parse_ring_buffer_or_channel,   0,                             offsetof(LinkConfig, channels.tx)
--- a/src/udev/udev-builtin-hwdb.c
+++ b/src/udev/udev-builtin-hwdb.c
@ -60,7 +60,7 @@ static const char *modalias_usb(sd_device *dev, char *s, size_t size) {
                return NULL;
        (void) sd_device_get_sysattr_value(dev, "product", &n);

-        snprintf(s, size, "usb:v%04Xp%04X:%s", vn, pn, strempty(n));
+        (void) snprintf(s, size, "usb:v%04Xp%04X:%s", vn, pn, strempty(n));
        return s;
 }

--- a/test/fuzz/fuzz-link-parser/directives.link
+++ b/test/fuzz/fuzz-link-parser/directives.link
@ -36,6 +36,7 @@ TCPSegmentationOffload=
 TCP6SegmentationOffload=
 UDPSegmentationOffload=
 GenericReceiveOffload=
+GenericReceiveOffloadHardware=
 LargeReceiveOffload=
 RxChannels=
 TxChannels=
--- a/test/test-functions
+++ b/test/test-functions
@ -1227,6 +1227,9 @@ check_result_common() {
            setfacl -m "user:${SUDO_USER:?}:r-X" "${TESTDIR:?}/"failed
        fi
        ret=1
+    elif get_bool "$TIMED_OUT"; then
+        echo "(timeout)" >"${TESTDIR:?}/failed"
+        ret=2
    elif [ -e "$workspace/testok" ]; then
        # …/testok always counts (but with lower priority than …/failed)
        ret=0
@ -1235,9 +1238,6 @@ check_result_common() {
        echo "${TESTNAME:?} was skipped:"
        cat "$workspace/skipped"
        ret=0
-    elif get_bool "$TIMED_OUT"; then
-        echo "(timeout)" >"${TESTDIR:?}/failed"
-        ret=2
    else
        echo "(failed; see logs)" >"${TESTDIR:?}/failed"
        ret=3
Author	SHA1	Message	Date
Yu Watanabe	218262c0b1	Merge pull request #20500 from poettering/import-tweaks a few minor tweaks/bugfixlets to importd backends	2021-08-21 12:50:22 +09:00
Yu Watanabe	455bb37a8b	Merge pull request #20499 from poettering/align-to-tweak ALIGN_TO() tweaks	2021-08-21 12:50:07 +09:00
Yu Watanabe	cc97ef5627	Merge pull request #20494 from bluca/snprintf_voidify tree-wide: voidify unchecked snprintf calls or use snprintf_ok	2021-08-21 06:45:58 +09:00
Yu Watanabe	0e0e57a484	Merge pull request #20484 from DaanDeMeyer/rx-gro-hw Add rx-gro-hw support	2021-08-21 06:43:49 +09:00
Frantisek Sumsal	faca95e115	test: make sure test timeout has a higher priority than a pass otherwise we might mark tests where something crashes during shutdown as successful, as happened in one of the recent TEST-01-BASIC runs: ``` testsuite-01.service: About to execute rm -f /failed /testok testsuite-01.service: Forked rm as 606 testsuite-01.service: Executing: rm -f /failed /testoktestsuite-01.service: Changed dead -> start-pre Starting TEST-01-BASIC... ... Child 606 (rm) died (code=exited, status=0/SUCCESS) testsuite-01.service: Child 606 belongs to testsuite-01.service. testsuite-01.service: Control process exited, code=exited, status=0/SUCCESS (success) testsuite-01.service: Got final SIGCHLD for state start-pre. testsuite-01.service: Passing 0 fds to service testsuite-01.service: About to execute sh -e -x -c "systemctl --state=failed --no-legend --no-pager >/failed ; systemctl daemon-reload ; echo OK >/testok" testsuite-01.service: Forked sh as 607 testsuite-01.service: Changed start-pre -> start testsuite-01.service: Executing: sh -e -x -c "systemctl --state=failed --no-legend --no-pager >/failed ; systemctl daemon-reload ; echo OK >/testok"systemd-journald.service: Got notification message from PID 560 (FDSTORE=1)S ... testsuite-01.service: Child 607 belongs to testsuite-01.service. testsuite-01.service: Main process exited, code=exited, status=0/SUCCESS (success) testsuite-01.service: Deactivated successfully. testsuite-01.service: Service will not restart (restart setting) testsuite-01.service: Changed start -> dead testsuite-01.service: Job 207 testsuite-01.service/start finished, result=done [ OK ] Finished TEST-01-BASIC. ... end.service: About to execute /bin/sh -x -c "systemctl poweroff --no-block" end.service: Forked /bin/sh as 623end.service: Executing: /bin/sh -x -c "systemctl poweroff --no-block" ... end.service: Job 213 end.service/start finished, result=canceled Caught <SEGV>, dumped core as pid 624. Freezing execution. CentOS Linux 8 Kernel 4.18.0-305.12.1.el8_4.x86_64 on an x86_64 (ttyS0) H login: qemu-kvm: terminating on signal 15 from pid 80134 (timeout) E: Test timed out after 600s Spawning getter /root/systemd/build/journalctl -o export -D /var/tmp/systemd-test.0UYjAS/root/var/log/journal/ca6031c2491543fe8286c748258df8d1... Finishing after writing 15125 entries Spawning getter /root/systemd/build/journalctl -o export -D /var/tmp/systemd-test.0UYjAS/root/var/log/journal/remote... Finishing after writing 0 entries -rw-r-----. 1 root root 25165824 Aug 20 12:26 /var/tmp/systemd-test.0UYjAS/system.journal TEST-01-BASIC RUN: Basic systemd setup [OK] ...	2021-08-21 06:40:25 +09:00
Lennart Poettering	c7ed718720	macro: handle overflow in ALIGN_TO() somewhat reasonably The helper call rounds up to next multiple of specified boundary. If one passes a very large value as first argument, then there might not be a next multiple. So far we ignored that. Let's handle this now and return SIZE_MAX in this case, as special indicator that we reached the end. Of course, IRL this should not happen. With this new change we at least do something somewhat reasonable, leaving it to the caller to handle it further.	2021-08-20 22:00:48 +02:00
Lennart Poettering	eeed637fea	test: split out macro tests into own test-macro.c No changes in code, just a split out of tests for stuff from macro.h into test-macro.c	2021-08-20 22:00:48 +02:00
Lennart Poettering	983b69c3f5	import-fs: create paren dirs in --direct mode too There's no reason not to create these in advance if they are missing.	2021-08-20 21:57:08 +02:00
Lennart Poettering	50b9c30cea	import: don't attempt full-file clones if we only are supposed to write a part of the file Otherwise we'll copy more than we were told to.	2021-08-20 21:57:04 +02:00
Lennart Poettering	bf284aee23	import: enable sparse file writing logic only for files we create Only if we create a file we know for sure that it is empty and hence our sparse file logic of skipping over NUL bytes can can work. If we hwoever are called to write data to some existing file/block device, we must do regular writes to override everything that might be in place before. Hence, conditionalize sparse file writing on the write offset not being configured (which is how we internally distinguish write to existing file and write to new file)	2021-08-20 21:56:59 +02:00
Lennart Poettering	53e03c9692	import: when completed, say how many bytes we wrote/acquired This is just too useful.	2021-08-20 21:56:55 +02:00
Lennart Poettering	c456862f87	import: allow file:// in addition to HTTP(S) Previously we only allows http/https urls, let's open this up a bit. Why? Because it makes testing so much easier as we don't need to run a HTTP server all the time. CURL mostly abstracts the differences of http/https away from us, hence we can get away with very little extra work.	2021-08-20 21:56:39 +02:00
Lennart Poettering	55b90ee00b	import: turn off weird protocols in curl Let's lock things down a bit and now allow curl's weirder protocols to be used with our use. i.e. stick to http:// + https:// + file:// and turn everything else off. (Gopher!) This is cde that interfaces with the network after all, and we better shouldn't support protocols needlessly that are much less tested. (Given that HTTP redirects (and other redirects) exist, this should give us a security benefit, since we will then be sure that noone can forward us to a weird protocol, which we never tested, and other people test neither)	2021-08-20 21:56:00 +02:00
Luca Boccassi	121ed16caf	tree-wide: voidify unchecked snprintf calls According to Coverity, 194 ouf of 227 times we check for snprintf return code. Voidify the rest. CID#1461512 CID#1461513 CID#1461514 CID#1461515 CID#1461516 CID#1461518 CID#1461519 CID#1461520 CID#1461522	2021-08-20 18:29:40 +01:00
Luca Boccassi	272fff7d84	format-util/sd-bus: do not ignore snprintf result	2021-08-20 18:29:30 +01:00
Luca Boccassi	e4193309c4	hwdb-usb-device: use xsprintf	2021-08-20 18:29:30 +01:00
Daan De Meyer	8f821d90bf	link: Add support for rx-gro-hw nic feature	2021-08-20 09:15:02 +01:00
Daan De Meyer	f20710c74c	link: Stop prefixing features with "the"	2021-08-20 09:14:14 +01:00