HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/network/networkd-setlink.c
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;
}