HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/network/networkd-setlink.c

52,881 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: f5a43788ef79275a426b4d12a661e23d1906569d

Lines 1001–1496 of 1,496

                        mtu = MAX(mtu, link_reduces_vlan_mtu(link) ? dev->mtu + 4 : dev->mtu);
 
                else if (dev->kind == NETDEV_KIND_MACVLAN && dev->mtu > mtu)
                        /* See macvlan_change_mtu() in kernel. */
                        mtu = dev->mtu;
 
        return mtu;
}
 
int link_configure_mtu(Link *link) {
        uint32_t mtu;
 
        assert(link);
        assert(link->network);
 
        if (link->network->mtu > 0)
                return link_request_to_set_mtu(link, link->network->mtu);
 
        mtu = link_get_requested_mtu_by_stacked_netdevs(link);
        if (link->mtu >= mtu)
                return 0;
 
        log_link_notice(link, "Bumping MTU bytes from %"PRIu32" to %"PRIu32" because of stacked device. "
                        "If it is not desired, then please explicitly specify MTUBytes= setting.",
                        link->mtu, mtu);
 
        return link_request_to_set_mtu(link, mtu);
}
 
static int link_up_dsa_slave(Link *link) {
        Link *master;
        int r;
 
        assert(link);
 
        /* For older kernels (specifically, older than 9d5ef190e5615a7b63af89f88c4106a5bc127974, kernel-5.12),
         * it is necessary to bring up a DSA slave that its master interface is already up. And bringing up
         * the slave fails with -ENETDOWN. So, let's bring up the master even if it is not managed by us,
         * and try to bring up the slave after the master becomes up. */
 
        if (link->dsa_master_ifindex <= 0)
                return 0;
 
        if (!streq_ptr(link->driver, "dsa"))
                return 0;
 
        if (link_get_by_index(link->manager, link->dsa_master_ifindex, &master) < 0)
                return 0;
 
        if (master->state == LINK_STATE_UNMANAGED) {
                /* If the DSA master interface is unmanaged, then it will never become up.
                 * Let's request to bring up the master. */
                r = link_request_to_bring_up_or_down(master, /* up= */ true);
                if (r < 0)
                        return r;
        }
 
        r = link_request_to_bring_up_or_down(link, /* up= */ true);
        if (r < 0)
                return r;
 
        return 1;
}
 
static const char* up_or_down(bool up) {
        return up ? "up" : "down";
}
 
static int link_up_or_down_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, void *userdata) {
        bool on_activate, up;
        int r;
 
        assert(m);
        assert(req);
        assert(link);
 
        on_activate = req->type == REQUEST_TYPE_ACTIVATE_LINK;
        up = PTR_TO_INT(req->userdata);
 
        r = sd_netlink_message_get_errno(m);
        if (r == -ENETDOWN && up && link_up_dsa_slave(link) > 0)
                log_link_message_debug_errno(link, m, r, "Could not bring up dsa slave, retrying again after dsa master becomes up");
        else if (r < 0)
                log_link_message_warning_errno(link, m, r, "Could not bring %s interface, ignoring", up_or_down(up));
 
        r = link_call_getlink(link, get_link_update_flag_handler);
        if (r < 0) {
                link_enter_failed(link);
                return 0;
        }
 
        link->set_flags_messages++;
 
        if (on_activate) {
                link->activated = true;
                link_check_ready(link);
        }
 
        return 0;
}
 
static int link_up_or_down(Link *link, bool up, Request *req) {
        _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
        int r;
 
        assert(link);
        assert(link->manager);
        assert(link->manager->rtnl);
        assert(req);
 
        /* The log message is checked in the test. Please also update test_bond_active_slave() in
         * test/test-network/systemd-networkd-tests.py. when the log message below is modified. */
        log_link_debug(link, "Bringing link %s", up_or_down(up));
 
        r = sd_rtnl_message_new_link(link->manager->rtnl, &m, RTM_SETLINK, link->ifindex);
        if (r < 0)
                return r;
 
        r = sd_rtnl_message_link_set_flags(m, up ? IFF_UP : 0, IFF_UP);
        if (r < 0)
                return r;
 
        return request_call_netlink_async(link->manager->rtnl, m, req);
}
 
static bool link_is_ready_to_activate_one(Link *link, bool allow_unmanaged) {
        assert(link);
 
        if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED, LINK_STATE_UNMANAGED))
                return false;
 
        if (!link->network)
                return allow_unmanaged;
 
        if (link->set_link_messages > 0)
                return false;
 
        return true;
}
 
 static bool link_is_ready_to_activate(Link *link, bool up) {
        assert(link);
 
        if (!check_ready_for_all_sr_iov_ports(link, /* allow_unmanaged= */ false,
                                              link_is_ready_to_activate_one))
                return false;
 
        if (up && link_rfkilled(link) > 0)
                return false;
 
        return true;
}
 
static int link_process_activation(Request *req, Link *link, void *userdata) {
        bool up = PTR_TO_INT(userdata);
        int r;
 
        assert(req);
        assert(link);
 
        if (!link_is_ready_to_activate(link, up))
                return 0;
 
        r = link_up_or_down(link, up, req);
        if (r < 0)
                return log_link_warning_errno(link, r, "Failed to activate link: %m");
 
        return 1;
}
 
int link_request_to_activate(Link *link) {
        bool up;
        int r;
 
        assert(link);
        assert(link->network);
 
        switch (link->network->activation_policy) {
        case ACTIVATION_POLICY_BOUND:
                r = link_handle_bound_to_list(link);
                if (r < 0)
                        return r;
                _fallthrough_;
        case ACTIVATION_POLICY_MANUAL:
                link->activated = true;
                link_check_ready(link);
                return 0;
        case ACTIVATION_POLICY_UP:
        case ACTIVATION_POLICY_ALWAYS_UP:
                up = true;
                break;
        case ACTIVATION_POLICY_DOWN:
        case ACTIVATION_POLICY_ALWAYS_DOWN:
                up = false;
                break;
        default:
                assert_not_reached();
        }
 
        link->activated = false;
 
        r = link_queue_request_full(link, REQUEST_TYPE_ACTIVATE_LINK,
                                    INT_TO_PTR(up), NULL, NULL, NULL,
                                    link_process_activation,
                                    &link->set_flags_messages,
                                    link_up_or_down_handler, NULL);
        if (r < 0)
                return log_link_error_errno(link, r, "Failed to request to activate link: %m");
 
        log_link_debug(link, "Requested to activate link");
        return 0;
}
 
static bool link_is_ready_to_bring_up_or_down(Link *link, bool up) {
        assert(link);
 
        if (up && link->dsa_master_ifindex > 0) {
                Link *master;
 
                /* The master interface must be up. See comments in link_up_dsa_slave(). */
 
                if (link_get_by_index(link->manager, link->dsa_master_ifindex, &master) < 0)
                        return false;
 
                if (!link_is_up(master))
                        return false;
        }
 
        if (link->state == LINK_STATE_UNMANAGED)
                return true;
 
        if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
                return false;
 
        if (link->set_link_messages > 0)
                return false;
 
        if (!link->activated)
                return false;
 
        if (up && link_rfkilled(link) > 0)
                return false;
 
        return true;
}
 
static int link_process_up_or_down(Request *req, Link *link, void *userdata) {
        bool up = PTR_TO_INT(userdata);
        int r;
 
        assert(req);
        assert(link);
 
        if (!link_is_ready_to_bring_up_or_down(link, up))
                return 0;
 
        r = link_up_or_down(link, up, req);
        if (r < 0)
                return log_link_warning_errno(link, r, "Failed to bring link %s: %m", up_or_down(up));
 
        return 1;
}
 
int link_request_to_bring_up_or_down(Link *link, bool up) {
        int r;
 
        assert(link);
 
        r = link_queue_request_full(link, REQUEST_TYPE_UP_DOWN,
                                    INT_TO_PTR(up), NULL, NULL, NULL,
                                    link_process_up_or_down,
                                    &link->set_flags_messages,
                                    link_up_or_down_handler, NULL);
        if (r < 0)
                return log_link_warning_errno(link, r, "Failed to request to bring link %s: %m",
                                              up_or_down(up));
 
        log_link_debug(link, "Requested to bring link %s", up_or_down(up));
        return 0;
}
 
static int link_up_or_down_now_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link, bool up) {
        int r;
 
        assert(m);
        assert(link);
        assert(link->set_flags_messages > 0);
 
        link->set_flags_messages--;
 
        if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
                return 0;
 
        r = sd_netlink_message_get_errno(m);
        if (r < 0)
                log_link_message_warning_errno(link, m, r, "Could not bring %s interface, ignoring", up_or_down(up));
 
        r = link_call_getlink(link, get_link_update_flag_handler);
        if (r < 0) {
                link_enter_failed(link);
                return 0;
        }
 
        link->set_flags_messages++;
        return 0;
}
 
static int link_up_now_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
        return link_up_or_down_now_handler(rtnl, m, link, /* up= */ true);
}
 
static int link_down_now_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
        return link_up_or_down_now_handler(rtnl, m, link, /* up= */ false);
}
 
int link_up_or_down_now(Link *link, bool up) {
        _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
        int r;
 
        assert(link);
        assert(link->manager);
        assert(link->manager->rtnl);
 
        log_link_debug(link, "Bringing link %s", up_or_down(up));
 
        r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
        if (r < 0)
                return log_link_warning_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
 
        r = sd_rtnl_message_link_set_flags(req, up ? IFF_UP : 0, IFF_UP);
        if (r < 0)
                return log_link_warning_errno(link, r, "Could not set link flags: %m");
 
        r = netlink_call_async(link->manager->rtnl, NULL, req,
                               up ? link_up_now_handler : link_down_now_handler,
                               link_netlink_destroy_callback, link);
        if (r < 0)
                return log_link_warning_errno(link, r, "Could not send rtnetlink message: %m");
 
        link->set_flags_messages++;
        link_ref(link);
        return 0;
}
 
typedef struct SetLinkVarlinkContext {
        Link *link;
        sd_varlink *vlink;
        bool up;
} SetLinkVarlinkContext;
 
static SetLinkVarlinkContext* set_link_varlink_context_free(SetLinkVarlinkContext *ctx) {
        if (!ctx)
                return NULL;
 
        if (ctx->vlink)
                sd_varlink_unref(ctx->vlink);
        if (ctx->link)
                link_unref(ctx->link);
        return mfree(ctx);
}
 
DEFINE_TRIVIAL_CLEANUP_FUNC(SetLinkVarlinkContext*, set_link_varlink_context_free);
 
static void set_link_varlink_context_destroy(SetLinkVarlinkContext *ctx) {
        set_link_varlink_context_free(ctx);
}
 
static int link_up_or_down_now_varlink_handler(sd_netlink *rtnl, sd_netlink_message *m, SetLinkVarlinkContext *ctx) {
        int r;
 
        assert(m);
        assert(ctx);
 
        Link *link = ASSERT_PTR(ctx->link);
        sd_varlink *vlink = ASSERT_PTR(ctx->vlink);
        bool up = ctx->up;
 
        assert(link->set_flags_messages > 0);
 
        link->set_flags_messages--;
 
        r = sd_netlink_message_get_errno(m);
        if (r < 0) {
                (void) sd_varlink_error_errno(vlink, r);
                log_link_message_warning_errno(link, m, r, "Could not bring %s interface", up_or_down(up));
        } else
                (void) sd_varlink_reply(vlink, NULL);
 
        if (link->state == LINK_STATE_LINGER)
                return 0;
 
        r = link_call_getlink(link, get_link_update_flag_handler);
        if (r < 0) {
                link_enter_failed(link);
                return 0;
        }
 
        link->set_flags_messages++;
        return 0;
}
 
int link_up_or_down_now_by_varlink(Link *link, bool up, sd_varlink *vlink) {
        _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
        int r;
 
        assert(link);
        assert(link->manager);
        assert(link->manager->rtnl);
 
        log_link_debug(link, "Bringing link %s (varlink)", up_or_down(up));
 
        r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
        if (r < 0)
                return log_link_warning_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
 
        r = sd_rtnl_message_link_set_flags(req, up ? IFF_UP : 0, IFF_UP);
        if (r < 0)
                return log_link_warning_errno(link, r, "Could not set link flags: %m");
 
        _cleanup_(set_link_varlink_context_freep) SetLinkVarlinkContext *ctx = new(SetLinkVarlinkContext, 1);
        if (!ctx)
                return log_oom();
 
        *ctx = (SetLinkVarlinkContext) {
                .link = link_ref(link),
                .vlink = sd_varlink_ref(vlink),
                .up = up,
        };
 
        r = netlink_call_async(link->manager->rtnl, NULL, req,
                               link_up_or_down_now_varlink_handler,
                               set_link_varlink_context_destroy,
                               ctx);
        if (r < 0)
                return log_link_warning_errno(link, r, "Could not send rtnetlink message: %m");
 
        TAKE_PTR(ctx);
        link->set_flags_messages++;
        return 0;
}
 
int link_down_slave_links(Link *link) {
        Link *slave;
        int r;
 
        assert(link);
 
        SET_FOREACH(slave, link->slaves) {
                r = link_down_now(slave);
                if (r < 0)
                        return r;
        }
 
        return 0;
}
 
static int link_remove_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
        int r;
 
        assert(m);
        assert(link);
 
        if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
                return 0;
 
        r = sd_netlink_message_get_errno(m);
        if (r < 0)
                log_link_message_warning_errno(link, m, r, "Could not remove interface, ignoring");
 
        return 0;
}
 
int link_remove(Link *link) {
        _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
        int r;
 
        assert(link);
        assert(link->manager);
        assert(link->manager->rtnl);
 
        log_link_debug(link, "Removing link.");
 
        r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_DELLINK, link->ifindex);
        if (r < 0)
                return log_link_debug_errno(link, r, "Could not allocate RTM_DELLINK message: %m");
 
        r = netlink_call_async(link->manager->rtnl, NULL, req, link_remove_handler,
                               link_netlink_destroy_callback, link);
        if (r < 0)
                return log_link_debug_errno(link, r, "Could not send rtnetlink message: %m");
 
        link_ref(link);
 
        return 0;
}