From: Zbigniew Jędrzejewski-Szmek <zbyszek@in.waw.pl>
Date: Wed, 5 Jan 2022 09:35:19 +0000 (+0100)
Subject: network: move logging from tc .fill_message to the callers
X-Git-Tag: v251-rc1~589^2~5
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=16924f54af8876f6437ad6c87251ae92ebfba778;p=thirdparty%2Fsystemd.git

network: move logging from tc .fill_message to the callers

Structured initialization is used a bit more.

There were two kinds of log messages: about failed size calculations and
about failed appends to the message. I "downgraded" the first type to log_debug,
and moved the latter to the caller. This way there should be at most one high-priority
message.

I also changed sizeof(<type>) to sizeof(var) — there is less chance of select-and-paste
error in the second form.
---

diff --git a/src/network/tc/cake.c b/src/network/tc/cake.c
index b4cbc4f9707..d52151e75d8 100644
--- a/src/network/tc/cake.c
+++ b/src/network/tc/cake.c
@@ -39,88 +39,88 @@ static int cake_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req)
         assert(qdisc);
         assert(req);
 
-        c = CAKE(qdisc);
+        assert_se(c = CAKE(qdisc));
 
         r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "cake");
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
+                return r;
 
         if (c->bandwidth > 0) {
                 r = sd_netlink_message_append_u64(req, TCA_CAKE_BASE_RATE64, c->bandwidth);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_CAKE_BASE_RATE64 attribute: %m");
+                        return r;
         }
 
         if (c->autorate >= 0) {
                 r = sd_netlink_message_append_u32(req, TCA_CAKE_AUTORATE, c->autorate);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_CAKE_AUTORATE attribute: %m");
+                        return r;
         }
 
         if (c->overhead_set) {
                 r = sd_netlink_message_append_s32(req, TCA_CAKE_OVERHEAD, c->overhead);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_CAKE_OVERHEAD attribute: %m");
+                        return r;
         }
 
         if (c->mpu > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_CAKE_MPU, c->mpu);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_CAKE_MPU attribute: %m");
+                        return r;
         }
 
         if (c->compensation_mode >= 0) {
                 r = sd_netlink_message_append_u32(req, TCA_CAKE_ATM, c->compensation_mode);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_CAKE_ATM attribute: %m");
+                        return r;
         }
 
         if (c->raw > 0) {
                 /* TCA_CAKE_RAW attribute is mostly a flag, not boolean. */
                 r = sd_netlink_message_append_u32(req, TCA_CAKE_RAW, 0);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_CAKE_RAW attribute: %m");
+                        return r;
         }
 
         if (c->flow_isolation_mode >= 0) {
                 r = sd_netlink_message_append_u32(req, TCA_CAKE_FLOW_MODE, c->flow_isolation_mode);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_CAKE_FLOW_MODE attribute: %m");
+                        return r;
         }
 
         if (c->nat >= 0) {
                 r = sd_netlink_message_append_u32(req, TCA_CAKE_NAT, c->nat);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_CAKE_NAT attribute: %m");
+                        return r;
         }
 
         if (c->preset >= 0) {
                 r = sd_netlink_message_append_u32(req, TCA_CAKE_DIFFSERV_MODE, c->preset);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_CAKE_DIFFSERV_MODE attribute: %m");
+                        return r;
         }
 
         if (c->fwmark > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_CAKE_FWMARK, c->fwmark);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_CAKE_FWMARK attribute: %m");
+                        return r;
         }
 
         if (c->wash >= 0) {
                 r = sd_netlink_message_append_u32(req, TCA_CAKE_WASH, c->wash);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_CAKE_WASH attribute: %m");
+                        return r;
         }
 
         if (c->split_gso >= 0) {
                 r = sd_netlink_message_append_u32(req, TCA_CAKE_SPLIT_GSO, c->split_gso);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_CAKE_SPLIT_GSO attribute: %m");
+                        return r;
         }
 
         r = sd_netlink_message_close_container(req);
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
+                return r;
 
         return 0;
 }
diff --git a/src/network/tc/codel.c b/src/network/tc/codel.c
index 33f40d87d44..23351bf3d12 100644
--- a/src/network/tc/codel.c
+++ b/src/network/tc/codel.c
@@ -31,45 +31,45 @@ static int controlled_delay_fill_message(Link *link, QDisc *qdisc, sd_netlink_me
         assert(qdisc);
         assert(req);
 
-        cd = CODEL(qdisc);
+        assert_se(cd = CODEL(qdisc));
 
         r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "codel");
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
+                return r;
 
         if (cd->packet_limit > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_CODEL_LIMIT, cd->packet_limit);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_CODEL_LIMIT attribute: %m");
+                        return r;
         }
 
         if (cd->interval_usec > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_CODEL_INTERVAL, cd->interval_usec);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_CODEL_INTERVAL attribute: %m");
+                        return r;
         }
 
         if (cd->target_usec > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_CODEL_TARGET, cd->target_usec);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_CODEL_TARGET attribute: %m");
+                        return r;
         }
 
         if (cd->ecn >= 0) {
                 r = sd_netlink_message_append_u32(req, TCA_CODEL_ECN, cd->ecn);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_CODEL_ECN attribute: %m");
+                        return r;
         }
 
         if (cd->ce_threshold_usec != USEC_INFINITY) {
                 r = sd_netlink_message_append_u32(req, TCA_CODEL_CE_THRESHOLD, cd->ce_threshold_usec);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_CODEL_CE_THRESHOLD attribute: %m");
+                        return r;
         }
 
         r = sd_netlink_message_close_container(req);
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
+                return r;
 
         return 0;
 }
diff --git a/src/network/tc/drr.c b/src/network/tc/drr.c
index ab67b0ad3e1..742a56f8c9d 100644
--- a/src/network/tc/drr.c
+++ b/src/network/tc/drr.c
@@ -23,21 +23,21 @@ static int drr_class_fill_message(Link *link, TClass *tclass, sd_netlink_message
         assert(tclass);
         assert(req);
 
-        drr = TCLASS_TO_DRR(tclass);
+        assert_se(drr = TCLASS_TO_DRR(tclass));
 
         r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "drr");
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
+                return r;
 
         if (drr->quantum > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_DRR_QUANTUM, drr->quantum);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_DRR_QUANTUM, attribute: %m");
+                        return r;
         }
 
         r = sd_netlink_message_close_container(req);
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
+                return r;
 
         return 0;
 }
diff --git a/src/network/tc/ets.c b/src/network/tc/ets.c
index f8dd1adabc8..c4d594cd1be 100644
--- a/src/network/tc/ets.c
+++ b/src/network/tc/ets.c
@@ -20,57 +20,57 @@ static int enhanced_transmission_selection_fill_message(Link *link, QDisc *qdisc
         assert(qdisc);
         assert(req);
 
-        ets = ETS(qdisc);
+        assert_se(ets = ETS(qdisc));
 
         r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "ets");
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
+                return r;
 
         r = sd_netlink_message_append_u8(req, TCA_ETS_NBANDS, ets->n_bands);
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not append TCA_ETS_NBANDS attribute: %m");
+                return r;
 
         if (ets->n_strict > 0) {
                 r = sd_netlink_message_append_u8(req, TCA_ETS_NSTRICT, ets->n_strict);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_ETS_NSTRICT attribute: %m");
+                        return r;
         }
 
         if (ets->n_quanta > 0) {
                 r = sd_netlink_message_open_container(req, TCA_ETS_QUANTA);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not open container TCA_ETS_QUANTA: %m");
+                        return r;
 
                 for (unsigned i = 0; i < ets->n_quanta; i++) {
                         r = sd_netlink_message_append_u32(req, TCA_ETS_QUANTA_BAND, ets->quanta[i]);
                         if (r < 0)
-                                return log_link_error_errno(link, r, "Could not append TCA_ETS_QUANTA_BAND attribute: %m");
+                                return r;
                 }
 
                 r = sd_netlink_message_close_container(req);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not close container TCA_ETS_QUANTA: %m");
+                        return r;
         }
 
         if (ets->n_prio > 0) {
                 r = sd_netlink_message_open_container(req, TCA_ETS_PRIOMAP);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not open container TCA_ETS_PRIOMAP: %m");
+                        return r;
 
                 for (unsigned i = 0; i < ets->n_prio; i++) {
                         r = sd_netlink_message_append_u8(req, TCA_ETS_PRIOMAP_BAND, ets->prio[i]);
                         if (r < 0)
-                                return log_link_error_errno(link, r, "Could not append TCA_ETS_PRIOMAP_BAND attribute: %m");
+                                return r;
                 }
 
                 r = sd_netlink_message_close_container(req);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not close container TCA_ETS_PRIOMAP: %m");
+                        return r;
         }
 
         r = sd_netlink_message_close_container(req);
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
+                return r;
 
         return 0;
 }
diff --git a/src/network/tc/fifo.c b/src/network/tc/fifo.c
index 3dd7f0b5f40..4f6e8fa613a 100644
--- a/src/network/tc/fifo.c
+++ b/src/network/tc/fifo.c
@@ -11,7 +11,6 @@
 #include "string-util.h"
 
 static int fifo_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
-        struct tc_fifo_qopt opt = {};
         FirstInFirstOut *fifo;
         int r;
 
@@ -21,23 +20,22 @@ static int fifo_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req)
 
         switch(qdisc->kind) {
         case QDISC_KIND_PFIFO:
-                fifo = PFIFO(qdisc);
+                assert_se(fifo = PFIFO(qdisc));
                 break;
         case QDISC_KIND_BFIFO:
-                fifo = BFIFO(qdisc);
+                assert_se(fifo = BFIFO(qdisc));
                 break;
         case QDISC_KIND_PFIFO_HEAD_DROP:
-                fifo = PFIFO_HEAD_DROP(qdisc);
+                assert_se(fifo = PFIFO_HEAD_DROP(qdisc));
                 break;
         default:
                 assert_not_reached();
         }
 
-        opt.limit = fifo->limit;
-
-        r = sd_netlink_message_append_data(req, TCA_OPTIONS, &opt, sizeof(struct tc_fifo_qopt));
+        const struct tc_fifo_qopt opt = { .limit = fifo->limit };
+        r = sd_netlink_message_append_data(req, TCA_OPTIONS, &opt, sizeof(opt));
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not append TCA_OPTIONS attribute: %m");
+                return r;
 
         return 0;
 }
diff --git a/src/network/tc/fq-codel.c b/src/network/tc/fq-codel.c
index 7c61cf2ac65..42dfd632a2b 100644
--- a/src/network/tc/fq-codel.c
+++ b/src/network/tc/fq-codel.c
@@ -33,63 +33,63 @@ static int fair_queueing_controlled_delay_fill_message(Link *link, QDisc *qdisc,
         assert(qdisc);
         assert(req);
 
-        fqcd = FQ_CODEL(qdisc);
+        assert_se(fqcd = FQ_CODEL(qdisc));
 
         r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "fq_codel");
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
+                return r;
 
         if (fqcd->packet_limit > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_FQ_CODEL_LIMIT, fqcd->packet_limit);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_FQ_CODEL_LIMIT attribute: %m");
+                        return r;
         }
 
         if (fqcd->flows > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_FQ_CODEL_FLOWS, fqcd->flows);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_FQ_CODEL_FLOWS attribute: %m");
+                        return r;
         }
 
         if (fqcd->quantum > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_FQ_CODEL_QUANTUM, fqcd->quantum);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_FQ_CODEL_QUANTUM attribute: %m");
+                        return r;
         }
 
         if (fqcd->interval_usec > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_FQ_CODEL_INTERVAL, fqcd->interval_usec);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_FQ_CODEL_INTERVAL attribute: %m");
+                        return r;
         }
 
         if (fqcd->target_usec > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_FQ_CODEL_TARGET, fqcd->target_usec);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_FQ_CODEL_TARGET attribute: %m");
+                        return r;
         }
 
         if (fqcd->ecn >= 0) {
                 r = sd_netlink_message_append_u32(req, TCA_FQ_CODEL_ECN, fqcd->ecn);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_FQ_CODEL_ECN attribute: %m");
+                        return r;
         }
 
         if (fqcd->ce_threshold_usec != USEC_INFINITY) {
                 r = sd_netlink_message_append_u32(req, TCA_FQ_CODEL_CE_THRESHOLD, fqcd->ce_threshold_usec);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_FQ_CODEL_CE_THRESHOLD attribute: %m");
+                        return r;
         }
 
         if (fqcd->memory_limit != UINT32_MAX) {
                 r = sd_netlink_message_append_u32(req, TCA_FQ_CODEL_MEMORY_LIMIT, fqcd->memory_limit);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_FQ_CODEL_MEMORY_LIMIT attribute: %m");
+                        return r;
         }
 
         r = sd_netlink_message_close_container(req);
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
+                return r;
 
         return 0;
 }
diff --git a/src/network/tc/fq-pie.c b/src/network/tc/fq-pie.c
index c7d7623b47b..d4a9d5966ac 100644
--- a/src/network/tc/fq-pie.c
+++ b/src/network/tc/fq-pie.c
@@ -18,21 +18,21 @@ static int fq_pie_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req
         assert(qdisc);
         assert(req);
 
-        fq_pie = FQ_PIE(qdisc);
+        assert_se(fq_pie = FQ_PIE(qdisc));
 
         r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "fq_pie");
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
+                return r;
 
         if (fq_pie->packet_limit > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_FQ_PIE_LIMIT, fq_pie->packet_limit);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_FQ_PIE_PLIMIT attribute: %m");
+                        return r;
         }
 
         r = sd_netlink_message_close_container(req);
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
+                return r;
 
         return 0;
 }
diff --git a/src/network/tc/fq.c b/src/network/tc/fq.c
index d10a863495c..1e69a66d7bb 100644
--- a/src/network/tc/fq.c
+++ b/src/network/tc/fq.c
@@ -32,46 +32,46 @@ static int fair_queueing_fill_message(Link *link, QDisc *qdisc, sd_netlink_messa
         assert(qdisc);
         assert(req);
 
-        fq = FQ(qdisc);
+        assert_se(fq = FQ(qdisc));
 
         r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "fq");
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
+                return r;
 
         if (fq->packet_limit > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_FQ_PLIMIT, fq->packet_limit);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_FQ_PLIMIT attribute: %m");
+                        return r;
         }
 
         if (fq->flow_limit > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_FQ_FLOW_PLIMIT, fq->flow_limit);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_FQ_FLOW_PLIMIT attribute: %m");
+                        return r;
         }
 
         if (fq->quantum > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_FQ_QUANTUM, fq->quantum);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_FQ_QUANTUM attribute: %m");
+                        return r;
         }
 
         if (fq->initial_quantum > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_FQ_INITIAL_QUANTUM, fq->initial_quantum);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_FQ_INITIAL_QUANTUM attribute: %m");
+                        return r;
         }
 
         if (fq->pacing >= 0) {
                 r = sd_netlink_message_append_u32(req, TCA_FQ_RATE_ENABLE, fq->pacing);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_FQ_RATE_ENABLE attribute: %m");
+                        return r;
         }
 
         if (fq->max_rate > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_FQ_FLOW_MAX_RATE, fq->max_rate);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_FQ_FLOW_MAX_RATE attribute: %m");
+                        return r;
         }
 
         if (fq->buckets > 0) {
@@ -80,24 +80,24 @@ static int fair_queueing_fill_message(Link *link, QDisc *qdisc, sd_netlink_messa
                 l = log2u(fq->buckets);
                 r = sd_netlink_message_append_u32(req, TCA_FQ_BUCKETS_LOG, l);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_FQ_BUCKETS_LOG attribute: %m");
+                        return r;
         }
 
         if (fq->orphan_mask > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_FQ_ORPHAN_MASK, fq->orphan_mask);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_FQ_ORPHAN_MASK attribute: %m");
+                        return r;
         }
 
         if (fq->ce_threshold_usec != USEC_INFINITY) {
                 r = sd_netlink_message_append_u32(req, TCA_FQ_CE_THRESHOLD, fq->ce_threshold_usec);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_FQ_CE_THRESHOLD attribute: %m");
+                        return r;
         }
 
         r = sd_netlink_message_close_container(req);
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
+                return r;
 
         return 0;
 }
diff --git a/src/network/tc/gred.c b/src/network/tc/gred.c
index ce26e62450f..96281e6bd46 100644
--- a/src/network/tc/gred.c
+++ b/src/network/tc/gred.c
@@ -24,32 +24,31 @@ static int generic_random_early_detection_init(QDisc *qdisc) {
 
 static int generic_random_early_detection_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
         GenericRandomEarlyDetection *gred;
-        struct tc_gred_sopt opt = {};
         int r;
 
         assert(link);
         assert(qdisc);
         assert(req);
 
-        gred = GRED(qdisc);
-
-        opt.DPs = gred->virtual_queues;
-        opt.def_DP = gred->default_virtual_queue;
+        assert_se(gred = GRED(qdisc));
 
-        if (gred->grio >= 0)
-                opt.grio = gred->grio;
+        const struct tc_gred_sopt opt = {
+                .DPs = gred->virtual_queues,
+                .def_DP = gred->default_virtual_queue,
+                .grio = gred->grio,
+        };
 
         r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "gred");
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
+                return r;
 
-        r = sd_netlink_message_append_data(req, TCA_GRED_DPS, &opt, sizeof(struct tc_gred_sopt));
+        r = sd_netlink_message_append_data(req, TCA_GRED_DPS, &opt, sizeof(opt));
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not append TCA_GRED_DPS attribute: %m");
+                return r;
 
         r = sd_netlink_message_close_container(req);
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
+                return r;
 
         return 0;
 }
diff --git a/src/network/tc/hhf.c b/src/network/tc/hhf.c
index 68a4b457102..aac4feff452 100644
--- a/src/network/tc/hhf.c
+++ b/src/network/tc/hhf.c
@@ -19,21 +19,21 @@ static int heavy_hitter_filter_fill_message(Link *link, QDisc *qdisc, sd_netlink
         assert(qdisc);
         assert(req);
 
-        hhf = HHF(qdisc);
+        assert_se(hhf = HHF(qdisc));
 
         r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "hhf");
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
+                return r;
 
         if (hhf->packet_limit > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_HHF_BACKLOG_LIMIT, hhf->packet_limit);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_HHF_BACKLOG_LIMIT attribute: %m");
+                        return r;
         }
 
        r = sd_netlink_message_close_container(req);
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
+                return r;
 
         return 0;
 }
diff --git a/src/network/tc/htb.c b/src/network/tc/htb.c
index 14fb1f92e34..78fcd3f05fe 100644
--- a/src/network/tc/htb.c
+++ b/src/network/tc/htb.c
@@ -16,31 +16,31 @@
 
 static int hierarchy_token_bucket_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
         HierarchyTokenBucket *htb;
-        struct tc_htb_glob opt = {
-                .version = 3,
-        };
         int r;
 
         assert(link);
         assert(qdisc);
         assert(req);
 
-        htb = HTB(qdisc);
+        assert_se(htb = HTB(qdisc));
 
-        opt.rate2quantum = htb->rate_to_quantum;
-        opt.defcls = htb->default_class;
+        struct tc_htb_glob opt = {
+                .version = 3,
+                .rate2quantum = htb->rate_to_quantum,
+                .defcls = htb->default_class,
+        };
 
         r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "htb");
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
+                return r;
 
         r = sd_netlink_message_append_data(req, TCA_HTB_INIT, &opt, sizeof(opt));
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not append TCA_HTB_INIT attribute: %m");
+                return r;
 
         r = sd_netlink_message_close_container(req);
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
+                return r;
         return 0;
 }
 
@@ -171,7 +171,6 @@ const QDiscVTable htb_vtable = {
 
 static int hierarchy_token_bucket_class_fill_message(Link *link, TClass *tclass, sd_netlink_message *req) {
         HierarchyTokenBucketClass *htb;
-        struct tc_htb_opt opt = {};
         uint32_t rtab[256], ctab[256];
         int r;
 
@@ -179,62 +178,65 @@ static int hierarchy_token_bucket_class_fill_message(Link *link, TClass *tclass,
         assert(tclass);
         assert(req);
 
-        htb = TCLASS_TO_HTB(tclass);
+        assert_se(htb = TCLASS_TO_HTB(tclass));
 
-        opt.prio = htb->priority;
-        opt.quantum = htb->quantum;
-        opt.rate.rate = (htb->rate >= (1ULL << 32)) ? ~0U : htb->rate;
-        opt.ceil.rate = (htb->ceil_rate >= (1ULL << 32)) ? ~0U : htb->ceil_rate;
-        opt.rate.overhead = htb->overhead;
-        opt.ceil.overhead = htb->overhead;
+        struct tc_htb_opt opt = {
+                .prio = htb->priority,
+                .quantum = htb->quantum,
+                .rate.rate = (htb->rate >= (1ULL << 32)) ? ~0U : htb->rate,
+                .ceil.rate = (htb->ceil_rate >= (1ULL << 32)) ? ~0U : htb->ceil_rate,
+                .rate.overhead = htb->overhead,
+                .ceil.overhead = htb->overhead,
+        };
 
         r = tc_transmit_time(htb->rate, htb->buffer, &opt.buffer);
         if (r < 0)
-                return log_link_error_errno(link, r, "Failed to calculate buffer size: %m");
+                return log_link_debug_errno(link, r, "Failed to calculate buffer size: %m");
 
         r = tc_transmit_time(htb->ceil_rate, htb->ceil_buffer, &opt.cbuffer);
         if (r < 0)
-                return log_link_error_errno(link, r, "Failed to calculate ceil buffer size: %m");
+                return log_link_debug_errno(link, r, "Failed to calculate ceil buffer size: %m");
 
         r = tc_fill_ratespec_and_table(&opt.rate, rtab, htb->mtu);
         if (r < 0)
-                return log_link_error_errno(link, r, "Failed to calculate rate table: %m");
+                return log_link_debug_errno(link, r, "Failed to calculate rate table: %m");
 
         r = tc_fill_ratespec_and_table(&opt.ceil, ctab, htb->mtu);
         if (r < 0)
-                return log_link_error_errno(link, r, "Failed to calculate ceil rate table: %m");
+                return log_link_debug_errno(link, r, "Failed to calculate ceil rate table: %m");
 
         r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "htb");
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
+                return r;
 
         r = sd_netlink_message_append_data(req, TCA_HTB_PARMS, &opt, sizeof(opt));
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not append TCA_HTB_PARMS attribute: %m");
+                return r;
 
         if (htb->rate >= (1ULL << 32)) {
                 r = sd_netlink_message_append_u64(req, TCA_HTB_RATE64, htb->rate);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_HTB_RATE64 attribute: %m");
+                        return r;
         }
 
         if (htb->ceil_rate >= (1ULL << 32)) {
                 r = sd_netlink_message_append_u64(req, TCA_HTB_CEIL64, htb->ceil_rate);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_HTB_CEIL64 attribute: %m");
+                        return r;
         }
 
         r = sd_netlink_message_append_data(req, TCA_HTB_RTAB, rtab, sizeof(rtab));
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not append TCA_HTB_RTAB attribute: %m");
+                return r;
 
         r = sd_netlink_message_append_data(req, TCA_HTB_CTAB, ctab, sizeof(ctab));
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not append TCA_HTB_CTAB attribute: %m");
+                return r;
 
         r = sd_netlink_message_close_container(req);
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
+                return r;
+
         return 0;
 }
 
diff --git a/src/network/tc/netem.c b/src/network/tc/netem.c
index 2d86d53125b..d4c452675e6 100644
--- a/src/network/tc/netem.c
+++ b/src/network/tc/netem.c
@@ -14,9 +14,6 @@
 #include "tc-util.h"
 
 static int network_emulator_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
-        struct tc_netem_qopt opt = {
-               .limit = 1000,
-        };
         NetworkEmulator *ne;
         int r;
 
@@ -24,16 +21,13 @@ static int network_emulator_fill_message(Link *link, QDisc *qdisc, sd_netlink_me
         assert(qdisc);
         assert(req);
 
-        ne = NETEM(qdisc);
-
-        if (ne->limit > 0)
-                opt.limit = ne->limit;
+        assert_se(ne = NETEM(qdisc));
 
-        if (ne->loss > 0)
-                opt.loss = ne->loss;
-
-        if (ne->duplicate > 0)
-                opt.duplicate = ne->duplicate;
+        struct tc_netem_qopt opt = {
+                .limit = ne->limit > 0 ? ne->limit : 1000,
+                .loss = ne->loss,
+                .duplicate = ne->duplicate,
+        };
 
         if (ne->delay != USEC_INFINITY) {
                 r = tc_time_to_tick(ne->delay, &opt.latency);
@@ -47,9 +41,9 @@ static int network_emulator_fill_message(Link *link, QDisc *qdisc, sd_netlink_me
                         return log_link_error_errno(link, r, "Failed to calculate jitter in TCA_OPTION: %m");
         }
 
-        r = sd_netlink_message_append_data(req, TCA_OPTIONS, &opt, sizeof(struct tc_netem_qopt));
+        r = sd_netlink_message_append_data(req, TCA_OPTIONS, &opt, sizeof(opt));
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not append TCA_OPTION attribute: %m");
+                return r;
 
         return 0;
 }
diff --git a/src/network/tc/pie.c b/src/network/tc/pie.c
index 4fcfe625b40..1b1a457f463 100644
--- a/src/network/tc/pie.c
+++ b/src/network/tc/pie.c
@@ -18,21 +18,21 @@ static int pie_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
         assert(qdisc);
         assert(req);
 
-        pie = PIE(qdisc);
+        assert_se(pie = PIE(qdisc));
 
         r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "pie");
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
+                return r;
 
         if (pie->packet_limit > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_PIE_LIMIT, pie->packet_limit);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_PIE_PLIMIT attribute: %m");
+                        return r;
         }
 
         r = sd_netlink_message_close_container(req);
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
+                return r;
 
         return 0;
 }
diff --git a/src/network/tc/qdisc.c b/src/network/tc/qdisc.c
index 2e0f0a12ebb..32b55e99f82 100644
--- a/src/network/tc/qdisc.c
+++ b/src/network/tc/qdisc.c
@@ -210,7 +210,7 @@ int qdisc_configure(Link *link, QDisc *qdisc) {
                 if (QDISC_VTABLE(qdisc)->fill_message) {
                         r = QDISC_VTABLE(qdisc)->fill_message(link, qdisc, req);
                         if (r < 0)
-                                return r;
+                                return log_link_error_errno(link, r, "Could not fill netlink message: %m");
                 }
         } else {
                 r = sd_netlink_message_append_string(req, TCA_KIND, qdisc->tca_kind);
diff --git a/src/network/tc/qfq.c b/src/network/tc/qfq.c
index d2e7b875efc..51aef032109 100644
--- a/src/network/tc/qfq.c
+++ b/src/network/tc/qfq.c
@@ -25,27 +25,28 @@ static int quick_fair_queueing_class_fill_message(Link *link, TClass *tclass, sd
         assert(tclass);
         assert(req);
 
-        qfq = TCLASS_TO_QFQ(tclass);
+        assert_se(qfq = TCLASS_TO_QFQ(tclass));
 
         r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "qfq");
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
+                return r;
 
         if (qfq->weight > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_QFQ_WEIGHT, qfq->weight);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_QFQ_WEIGHT attribute: %m");
+                        return r;
         }
 
         if (qfq->max_packet > 0) {
                 r = sd_netlink_message_append_u32(req, TCA_QFQ_LMAX, qfq->max_packet);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_QFQ_LMAX attribute: %m");
+                        return r;
         }
 
         r = sd_netlink_message_close_container(req);
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
+                return r;
+
         return 0;
 }
 
diff --git a/src/network/tc/sfb.c b/src/network/tc/sfb.c
index a4ca4884b18..88b3ce55bdc 100644
--- a/src/network/tc/sfb.c
+++ b/src/network/tc/sfb.c
@@ -13,7 +13,15 @@
 
 static int stochastic_fair_blue_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
         StochasticFairBlue *sfb;
-        struct tc_sfb_qopt opt = {
+        int r;
+
+        assert(link);
+        assert(qdisc);
+        assert(req);
+
+        assert_se(sfb = SFB(qdisc));
+
+        const struct tc_sfb_qopt opt = {
             .rehash_interval = 600*1000,
             .warmup_time = 60*1000,
             .penalty_rate = 10,
@@ -22,28 +30,20 @@ static int stochastic_fair_blue_fill_message(Link *link, QDisc *qdisc, sd_netlin
             .decrement = (SFB_MAX_PROB + 10000) / 20000,
             .max = 25,
             .bin_size = 20,
+            .limit = sfb->packet_limit,
         };
-        int r;
-
-        assert(link);
-        assert(qdisc);
-        assert(req);
-
-        sfb = SFB(qdisc);
-
-        opt.limit = sfb->packet_limit;
 
         r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "sfb");
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
+                return r;
 
-        r = sd_netlink_message_append_data(req, TCA_SFB_PARMS, &opt, sizeof(struct tc_sfb_qopt));
+        r = sd_netlink_message_append_data(req, TCA_SFB_PARMS, &opt, sizeof(opt));
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not append TCA_SFB_PARMS attribute: %m");
+                return r;
 
         r = sd_netlink_message_close_container(req);
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
+                return r;
 
         return 0;
 }
diff --git a/src/network/tc/sfq.c b/src/network/tc/sfq.c
index f67ffc186df..45cc54d3961 100644
--- a/src/network/tc/sfq.c
+++ b/src/network/tc/sfq.c
@@ -13,20 +13,21 @@
 
 static int stochastic_fairness_queueing_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
         StochasticFairnessQueueing *sfq;
-        struct tc_sfq_qopt_v1 opt = {};
         int r;
 
         assert(link);
         assert(qdisc);
         assert(req);
 
-        sfq = SFQ(qdisc);
+        assert_se(sfq = SFQ(qdisc));
 
-        opt.v0.perturb_period = sfq->perturb_period / USEC_PER_SEC;
+        const struct tc_sfq_qopt_v1 opt = {
+                .v0.perturb_period = sfq->perturb_period / USEC_PER_SEC,
+        };
 
-        r = sd_netlink_message_append_data(req, TCA_OPTIONS, &opt, sizeof(struct tc_sfq_qopt_v1));
+        r = sd_netlink_message_append_data(req, TCA_OPTIONS, &opt, sizeof(opt));
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not append TCA_OPTIONS attribute: %m");
+                return r;
 
         return 0;
 }
diff --git a/src/network/tc/tbf.c b/src/network/tc/tbf.c
index 1d1bc6f0e90..2aca8c1f13f 100644
--- a/src/network/tc/tbf.c
+++ b/src/network/tc/tbf.c
@@ -17,7 +17,6 @@
 
 static int token_bucket_filter_fill_message(Link *link, QDisc *qdisc, sd_netlink_message *req) {
         uint32_t rtab[256], ptab[256];
-        struct tc_tbf_qopt opt = {};
         TokenBucketFilter *tbf;
         int r;
 
@@ -25,10 +24,13 @@ static int token_bucket_filter_fill_message(Link *link, QDisc *qdisc, sd_netlink
         assert(qdisc);
         assert(req);
 
-        tbf = TBF(qdisc);
+        assert_se(tbf = TBF(qdisc));
 
-        opt.rate.rate = tbf->rate >= (1ULL << 32) ? ~0U : tbf->rate;
-        opt.peakrate.rate = tbf->peak_rate >= (1ULL << 32) ? ~0U : tbf->peak_rate;
+        struct tc_tbf_qopt opt = {
+                .rate.rate = tbf->rate >= (1ULL << 32) ? ~0U : tbf->rate,
+                .peakrate.rate = tbf->peak_rate >= (1ULL << 32) ? ~0U : tbf->peak_rate,
+                .rate.mpu = tbf->mpu,
+        };
 
         if (tbf->limit > 0)
                 opt.limit = tbf->limit;
@@ -43,69 +45,67 @@ static int token_bucket_filter_fill_message(Link *link, QDisc *qdisc, sd_netlink
                 opt.limit = lim;
         }
 
-        opt.rate.mpu = tbf->mpu;
-
         r = tc_fill_ratespec_and_table(&opt.rate, rtab, tbf->mtu);
         if (r < 0)
-                return log_link_error_errno(link, r, "Failed to calculate ratespec: %m");
+                return log_link_debug_errno(link, r, "Failed to calculate ratespec: %m");
 
         r = tc_transmit_time(opt.rate.rate, tbf->burst, &opt.buffer);
         if (r < 0)
-                return log_link_error_errno(link, r, "Failed to calculate buffer size: %m");
+                return log_link_debug_errno(link, r, "Failed to calculate buffer size: %m");
 
         if (opt.peakrate.rate > 0) {
                 opt.peakrate.mpu = tbf->mpu;
 
                 r = tc_fill_ratespec_and_table(&opt.peakrate, ptab, tbf->mtu);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Failed to calculate ratespec: %m");
+                        return log_link_debug_errno(link, r, "Failed to calculate ratespec: %m");
 
                 r = tc_transmit_time(opt.peakrate.rate, tbf->mtu, &opt.mtu);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Failed to calculate mtu size: %m");
+                        return log_link_debug_errno(link, r, "Failed to calculate mtu size: %m");
         }
 
         r = sd_netlink_message_open_container_union(req, TCA_OPTIONS, "tbf");
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not open container TCA_OPTIONS: %m");
+                return r;
 
-        r = sd_netlink_message_append_data(req, TCA_TBF_PARMS, &opt, sizeof(struct tc_tbf_qopt));
+        r = sd_netlink_message_append_data(req, TCA_TBF_PARMS, &opt, sizeof(opt));
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not append TCA_TBF_PARMS attribute: %m");
+                return r;
 
         r = sd_netlink_message_append_data(req, TCA_TBF_BURST, &tbf->burst, sizeof(tbf->burst));
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not append TCA_TBF_BURST attribute: %m");
+                return r;
 
         if (tbf->rate >= (1ULL << 32)) {
                 r = sd_netlink_message_append_u64(req, TCA_TBF_RATE64, tbf->rate);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_TBF_RATE64 attribute: %m");
+                        return r;
         }
 
         r = sd_netlink_message_append_data(req, TCA_TBF_RTAB, rtab, sizeof(rtab));
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not append TCA_TBF_RTAB attribute: %m");
+                return r;
 
         if (opt.peakrate.rate > 0) {
                 if (tbf->peak_rate >= (1ULL << 32)) {
                         r = sd_netlink_message_append_u64(req, TCA_TBF_PRATE64, tbf->peak_rate);
                         if (r < 0)
-                                return log_link_error_errno(link, r, "Could not append TCA_TBF_PRATE64 attribute: %m");
+                                return r;
                 }
 
                 r = sd_netlink_message_append_u32(req, TCA_TBF_PBURST, tbf->mtu);
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_TBF_PBURST attribute: %m");
+                        return r;
 
                 r = sd_netlink_message_append_data(req, TCA_TBF_PTAB, ptab, sizeof(ptab));
                 if (r < 0)
-                        return log_link_error_errno(link, r, "Could not append TCA_TBF_PTAB attribute: %m");
+                        return r;
         }
 
         r = sd_netlink_message_close_container(req);
         if (r < 0)
-                return log_link_error_errno(link, r, "Could not close container TCA_OPTIONS: %m");
+                return r;
 
         return 0;
 }
diff --git a/src/network/tc/tclass.c b/src/network/tc/tclass.c
index d8145997f04..24a66579f97 100644
--- a/src/network/tc/tclass.c
+++ b/src/network/tc/tclass.c
@@ -158,7 +158,7 @@ int tclass_configure(Link *link, TClass *tclass) {
         if (TCLASS_VTABLE(tclass)->fill_message) {
                 r = TCLASS_VTABLE(tclass)->fill_message(link, tclass, req);
                 if (r < 0)
-                        return r;
+                        return log_link_error_errno(link, r, "Could not fill netlink message: %m");
         }
 
         r = netlink_call_async(link->manager->rtnl, NULL, req, tclass_handler, link_netlink_destroy_callback, link);