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[STRLEN("usb:vp") + DECIMAL_STR_MAX(uint16_t) * 2];
+  char match[15];
   sd_hwdb *hwdb;
   const char *key, *value;
   int r;
 
   /* Match this USB vendor and product ID combination */
-  xsprintf(match, "usb:v%04Xp%04X", vid, pid);
+  snprintf(match, sizeof match, "usb:v%04Xp%04X", vid, pid);
 
   r = sd_hwdb_new(&hwdb);
   if (r < 0)

man/systemd.link.xml

@@ -662,56 +662,49 @@
       <varlistentry>
         <term><varname>ReceiveChecksumOffload=</varname></term>
         <listitem>
-          <para>Takes a boolean. If set to true, hardware offload for checksumming of ingress
+          <para>Takes a boolean. If set to true, the 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, hardware offload for checksumming of egress
+          <para>Takes a boolean. If set to true, the 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, TCP Segmentation Offload (TSO) is enabled.
+          <para>Takes a boolean. If set to true, the 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, TCP6 Segmentation Offload (tx-tcp6-segmentation) is enabled.
+          <para>Takes a boolean. If set to true, the 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, Generic Segmentation Offload (GSO) is enabled.
+          <para>Takes a boolean. If set to true, the 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, Generic Receive Offload (GRO) is enabled.
+          <para>Takes a boolean. If set to true, the 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, Large Receive Offload (LRO) is enabled.
+          <para>Takes a boolean. If set to true, the Large Receive Offload (LRO) is enabled.
           When unset, the kernel's default will be used.</para>
         </listitem>
       </varlistentry>
@@ -743,7 +736,7 @@
       <varlistentry>
         <term><varname>RxFlowControl=</varname></term>
         <listitem>
-          <para>Takes a boolean. When set, enables receive flow control, also known as the ethernet
+          <para>Takes a boolean. When set, enables the 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>
@@ -751,7 +744,7 @@
       <varlistentry>
         <term><varname>TxFlowControl=</varname></term>
         <listitem>
-          <para>Takes a boolean. When set, enables transmit flow control, also known as the ethernet
+          <para>Takes a boolean. When set, enables the 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>
@@ -759,7 +752,7 @@
       <varlistentry>
         <term><varname>AutoNegotiationFlowControl=</varname></term>
         <listitem>
-          <para>Takes a boolean. When set, auto negotiation enables the interface to exchange state
+          <para>Takes a boolean. When set, the 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>

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))
-                assert(snprintf_ok(buf, IF_NAMESIZE + 1, "%%%d", ifindex));
+                snprintf(buf, IF_NAMESIZE + 1, "%%%d", ifindex);
         else
-                assert(snprintf_ok(buf, IF_NAMESIZE + 1, "%d", ifindex));
+                snprintf(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) {
-                                (void) snprintf(buf, l,
+                                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
-                                (void) snprintf(buf, l,
+                                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;
                 }
 
-        (void) snprintf(buf, l, "%" PRIu64 "%s", t, flag & FORMAT_BYTES_TRAILING_B ? "B" : "");
+        snprintf(buf, l, "%" PRIu64 "%s", t, flag & FORMAT_BYTES_TRAILING_B ? "B" : "");
 
 finish:
         buf[l-1] = 0;

src/basic/macro.h

@@ -146,20 +146,6 @@
 #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));
 }
 

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;
 
-                (void) snprintf(buf, l, USEC_FMT " %s " USEC_FMT " %s %s",
+                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;
 
-                (void) snprintf(buf, l, USEC_FMT " %s " USEC_FMT " %s %s",
+                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;
 
-                (void) snprintf(buf, l, USEC_FMT " %s " USEC_FMT " %s %s",
+                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)
-                (void) snprintf(buf, l, USEC_FMT " days %s", d / USEC_PER_DAY, s);
+                snprintf(buf, l, USEC_FMT " days %s", d / USEC_PER_DAY, s);
         else if (d >= 25*USEC_PER_HOUR)
-                (void) snprintf(buf, l, "1 day " USEC_FMT "h %s",
+                snprintf(buf, l, "1 day " USEC_FMT "h %s",
                          (d - USEC_PER_DAY) / USEC_PER_HOUR, s);
         else if (d >= 6*USEC_PER_HOUR)
-                (void) snprintf(buf, l, USEC_FMT "h %s",
+                snprintf(buf, l, USEC_FMT "h %s",
                          d / USEC_PER_HOUR, s);
         else if (d >= USEC_PER_HOUR)
-                (void) snprintf(buf, l, USEC_FMT "h " USEC_FMT "min %s",
+                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)
-                (void) snprintf(buf, l, USEC_FMT "min %s",
+                snprintf(buf, l, USEC_FMT "min %s",
                          d / USEC_PER_MINUTE, s);
         else if (d >= USEC_PER_MINUTE)
-                (void) snprintf(buf, l, USEC_FMT "min " USEC_FMT "s %s",
+                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)
-                (void) snprintf(buf, l, USEC_FMT "s %s",
+                snprintf(buf, l, USEC_FMT "s %s",
                          d / USEC_PER_SEC, s);
         else if (d >= USEC_PER_MSEC)
-                (void) snprintf(buf, l, USEC_FMT "ms %s",
+                snprintf(buf, l, USEC_FMT "ms %s",
                          d / USEC_PER_MSEC, s);
         else if (d > 0)
-                (void) snprintf(buf, l, USEC_FMT"us %s",
+                snprintf(buf, l, USEC_FMT"us %s",
                          d, s);
         else
-                (void) snprintf(buf, l, "now");
+                snprintf(buf, l, "now");
 
         buf[l-1] = 0;
         return buf;

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) {
-               (void) snprintf(buf, l, USEC_FMT, t);
+               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) {
-                (void) snprintf(buf, l, "%" PRIu64, t);
+                snprintf(buf, l, "%" PRIu64, t);
                 return buf;
         }
         return format_bytes(buf, l, t);

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) {
-                (void) snprintf(buf, l, " (error getting kernel value: %s)", strerror_safe(r));
+                snprintf(buf, l, " (error getting kernel value: %s)", strerror_safe(r));
                 return buf;
         }
 
-        (void) snprintf(buf, l, " (different value in kernel: %" PRIu64 ")", kval);
+        snprintf(buf, l, " (different value in kernel: %" PRIu64 ")", kval);
 
         return buf;
 }

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);
 
-        (void) snprintf(msgbuf, msgbufsize,
+        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 ? "\"" : "",

src/import/curl-util.c

@@ -256,9 +256,6 @@ 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;
 }

src/import/import-fs.c

@@ -185,11 +185,10 @@ 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 };
 
         {

src/import/import-raw.c

@@ -9,7 +9,6 @@
 #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"
@@ -249,8 +248,6 @@ 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;
 }
 
@@ -322,9 +319,6 @@ 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;
 
@@ -371,7 +365,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) && i->offset == UINT64_MAX) {
+        if (S_ISREG(i->output_stat.st_mode)) {
                 ssize_t n;
 
                 n = sparse_write(i->output_fd, p, sz, 64);

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) && !file_url_is_valid(remote))
+        if (!http_url_is_valid(remote))
                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
                                          "URL %s is invalid", remote);
 

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 protocol;
+        long status;
         int r;
 
         if (curl_easy_getinfo(curl, CURLINFO_PRIVATE, (char **)&j) != CURLE_OK)
@@ -131,22 +131,11 @@ 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;
-                }
-
-                if (status == 304) {
+        } else if (status == 304) {
                 log_info("Image already downloaded. Skipping download.");
                 j->etag_exists = true;
                 r = 0;
@@ -187,7 +176,6 @@ 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.");
@@ -272,8 +260,6 @@ void pull_job_curl_on_finished(CurlGlue *g, CURL *curl, CURLcode result) {
                 }
         }
 
-        log_info("Acquired %s.", FORMAT_BYTES(j->written_uncompressed));
-
         r = 0;
 
 finish:
@@ -306,7 +292,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) && j->offset == UINT64_MAX) {
+                if (S_ISREG(j->disk_stat.st_mode)) {
                         ssize_t n;
 
                         n = sparse_write(j->disk_fd, p, sz, 64);

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) && !file_url_is_valid(url))
+        if (!http_url_is_valid(url))
                 return -EINVAL;
 
         if (local && !pull_validate_local(local, flags))

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) && !file_url_is_valid(url))
+        if (!http_url_is_valid(url))
                 return -EINVAL;
 
         if (local && !pull_validate_local(local, flags))

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) && !file_url_is_valid(url))
+        if (!http_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) && !file_url_is_valid(url))
+        if (!http_url_is_valid(url))
                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "URL '%s' is not valid.", url);
 
         if (argc >= 3)

src/libsystemd/sd-bus/bus-match.c

@@ -997,16 +997,20 @@ 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:
-                return snprintf_ok(buf, l, "arg%i", t - BUS_MATCH_ARG);
+                snprintf(buf, l, "arg%i", t - BUS_MATCH_ARG);
+                return buf;
 
         case BUS_MATCH_ARG_PATH ... BUS_MATCH_ARG_PATH_LAST:
-                return snprintf_ok(buf, l, "arg%ipath", t - BUS_MATCH_ARG_PATH);
+                snprintf(buf, l, "arg%ipath", t - BUS_MATCH_ARG_PATH);
+                return buf;
 
         case BUS_MATCH_ARG_NAMESPACE ... BUS_MATCH_ARG_NAMESPACE_LAST:
-                return snprintf_ok(buf, l, "arg%inamespace", t - BUS_MATCH_ARG_NAMESPACE);
+                snprintf(buf, l, "arg%inamespace", t - BUS_MATCH_ARG_NAMESPACE);
+                return buf;
 
         case BUS_MATCH_ARG_HAS ... BUS_MATCH_ARG_HAS_LAST:
-                return snprintf_ok(buf, l, "arg%ihas", t - BUS_MATCH_ARG_HAS);
+                snprintf(buf, l, "arg%ihas", t - BUS_MATCH_ARG_HAS);
+                return buf;
 
         default:
                 return NULL;

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) && !file_url_is_valid(remote))
+        if (!http_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) && !file_url_is_valid(remote))
+        if (!http_url_is_valid(remote))
                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                        "URL '%s' is not valid.", remote);
 

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);
 
-        (void) snprintf(buf, buf_size, "%s %s%s%.0u %s%s%.0u",
+        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);

src/shared/ethtool-util.c

@@ -74,7 +74,6 @@ 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",

src/shared/ethtool-util.h

@@ -23,7 +23,6 @@ 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,

src/shared/web-util.c

@@ -36,29 +36,16 @@ 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) || file_url_is_valid(url))
+        if (http_url_is_valid(url))
                 return true;
 
-        p = STARTSWITH_SET(url, "info:", "man:");
+        p = STARTSWITH_SET(url, "file:/", "info:", "man:");
         if (isempty(p))
                 return false;
 

src/shared/web-util.h

@@ -6,7 +6,6 @@
 #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_;
 

src/test/meson.build

@@ -188,8 +188,6 @@ tests += [
 
         [['src/test/test-util.c']],
 
-        [['src/test/test-macro.c']],
-
         [['src/test/test-json.c']],
 
         [['src/test/test-modhex.c']],

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:
-                (void) snprintf(buf, buf_len, "%i", status);
+                snprintf(buf, buf_len, "%i", status);
                 return buf;
         }
 };

src/test/test-macro.c

@@ -1,343 +0,0 @@
-/* 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;
-}

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;
 
-        (void) snprintf(buf, buf_len, "%i", family);
+        snprintf(buf, buf_len, "%i", family);
         return buf;
 }
 

src/test/test-util.c

@@ -17,6 +17,191 @@
 #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__);
 
@@ -64,6 +249,18 @@ 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__);
 
@@ -212,12 +409,109 @@ 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();
@@ -225,6 +519,8 @@ 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;
 }

src/udev/net/link-config-gperf.gperf

@@ -57,7 +57,6 @@ 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)

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);
 
-        (void) snprintf(s, size, "usb:v%04Xp%04X:%s", vn, pn, strempty(n));
+        snprintf(s, size, "usb:v%04Xp%04X:%s", vn, pn, strempty(n));
         return s;
 }
 

test/fuzz/fuzz-link-parser/directives.link

@@ -36,7 +36,6 @@ TCPSegmentationOffload=
 TCP6SegmentationOffload=
 UDPSegmentationOffload=
 GenericReceiveOffload=
-GenericReceiveOffloadHardware=
 LargeReceiveOffload=
 RxChannels=
 TxChannels=

test/test-functions

@@ -1227,9 +1227,6 @@ 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
@@ -1238,6 +1235,9 @@ 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