[thirdparty/systemd.git] / src / network / networkd-can.c

/* SPDX-License-Identifier: LGPL-2.1+ */

#include <net/if.h>
#include <linux/can/netlink.h>

#include "netlink-util.h"
#include "networkd-can.h"
#include "networkd-link.h"
#include "networkd-manager.h"
#include "parse-util.h"
#include "string-util.h"

#define CAN_TERMINATION_OHM_VALUE 120

int config_parse_can_bitrate(
                const char* unit,
                const char *filename,
                unsigned line,
                const char *section,
                unsigned section_line,
                const char *lvalue,
                int ltype,
                const char *rvalue,
                void *data,
                void *userdata) {

        uint32_t *br = data;
        uint64_t sz;
        int r;

        assert(filename);
        assert(lvalue);
        assert(rvalue);
        assert(data);

        r = parse_size(rvalue, 1000, &sz);
        if (r < 0) {
                log_syntax(unit, LOG_ERR, filename, line, r,
                           "Failed to parse can bitrate '%s', ignoring: %m", rvalue);
                return 0;
        }

        /* Linux uses __u32 for bitrates, so the value should not exceed that. */
        if (sz <= 0 || sz > UINT32_MAX) {
                log_syntax(unit, LOG_ERR, filename, line, 0,
                           "Bit rate out of permitted range 1...4294967295");
                return 0;
        }

        *br = (uint32_t) sz;

        return 0;
}

static int link_up_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
        int r;

        assert(link);

        if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
                return 1;

        r = sd_netlink_message_get_errno(m);
        if (r < 0)
                /* we warn but don't fail the link, as it may be brought up later */
                log_link_message_warning_errno(link, m, r, "Could not bring up interface");

        return 1;
}

static int link_up_can(Link *link) {
        _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
        int r;

        assert(link);

        log_link_debug(link, "Bringing CAN link up");

        r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
        if (r < 0)
                return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");

        r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
        if (r < 0)
                return log_link_error_errno(link, r, "Could not set link flags: %m");

        r = netlink_call_async(link->manager->rtnl, NULL, req, link_up_handler,
                               link_netlink_destroy_callback, link);
        if (r < 0)
                return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");

        link_ref(link);

        return 0;
}

static int link_set_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
        int r;

        assert(link);

        log_link_debug(link, "Set link");

        r = sd_netlink_message_get_errno(m);
        if (r < 0 && r != -EEXIST) {
                log_link_message_warning_errno(link, m, r, "Failed to configure CAN link");
                link_enter_failed(link);
        }

        return 1;
}

static int link_set_can(Link *link) {
        _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
        struct can_ctrlmode cm = {};
        int r;

        assert(link);
        assert(link->network);
        assert(link->manager);
        assert(link->manager->rtnl);

        log_link_debug(link, "Configuring CAN link.");

        r = sd_rtnl_message_new_link(link->manager->rtnl, &m, RTM_NEWLINK, link->ifindex);
        if (r < 0)
                return log_link_error_errno(link, r, "Failed to allocate netlink message: %m");

        r = sd_netlink_message_set_flags(m, NLM_F_REQUEST | NLM_F_ACK);
        if (r < 0)
                return log_link_error_errno(link, r, "Could not set netlink flags: %m");

        r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
        if (r < 0)
                return log_link_error_errno(link, r, "Failed to open netlink container: %m");

        r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, link->kind);
        if (r < 0)
                return log_link_error_errno(link, r, "Could not append IFLA_INFO_DATA attribute: %m");

        if (link->network->can_bitrate > 0 || link->network->can_sample_point > 0) {
                struct can_bittiming bt = {
                        .bitrate = link->network->can_bitrate,
                        .sample_point = link->network->can_sample_point,
                };

                log_link_debug(link, "Setting bitrate = %d bit/s", bt.bitrate);
                if (link->network->can_sample_point > 0)
                        log_link_debug(link, "Setting sample point = %d.%d%%", bt.sample_point / 10, bt.sample_point % 10);
                else
                        log_link_debug(link, "Using default sample point");

                r = sd_netlink_message_append_data(m, IFLA_CAN_BITTIMING, &bt, sizeof(bt));
                if (r < 0)
                        return log_link_error_errno(link, r, "Could not append IFLA_CAN_BITTIMING attribute: %m");
        }

        if (link->network->can_data_bitrate > 0 || link->network->can_data_sample_point > 0) {
                struct can_bittiming bt = {
                        .bitrate = link->network->can_data_bitrate,
                        .sample_point = link->network->can_data_sample_point,
                };

                log_link_debug(link, "Setting data bitrate = %d bit/s", bt.bitrate);
                if (link->network->can_data_sample_point > 0)
                        log_link_debug(link, "Setting data sample point = %d.%d%%", bt.sample_point / 10, bt.sample_point % 10);
                else
                        log_link_debug(link, "Using default data sample point");

                r = sd_netlink_message_append_data(m, IFLA_CAN_DATA_BITTIMING, &bt, sizeof(bt));
                if (r < 0)
                        return log_link_error_errno(link, r, "Could not append IFLA_CAN_DATA_BITTIMING attribute: %m");
        }

        if (link->network->can_fd_mode >= 0) {
                cm.mask |= CAN_CTRLMODE_FD;
                SET_FLAG(cm.flags, CAN_CTRLMODE_FD, link->network->can_fd_mode > 0);
                log_link_debug(link, "%sabling FD mode", link->network->can_fd_mode > 0 ? "En" : "Dis");
        }

        if (link->network->can_non_iso >= 0) {
                cm.mask |= CAN_CTRLMODE_FD_NON_ISO;
                SET_FLAG(cm.flags, CAN_CTRLMODE_FD_NON_ISO, link->network->can_non_iso > 0);
                log_link_debug(link, "%sabling FD non-ISO mode", link->network->can_non_iso > 0 ? "En" : "Dis");
        }

        if (link->network->can_restart_us > 0) {
                char time_string[FORMAT_TIMESPAN_MAX];
                uint64_t restart_ms;

                if (link->network->can_restart_us == USEC_INFINITY)
                        restart_ms = 0;
                else
                        restart_ms = DIV_ROUND_UP(link->network->can_restart_us, USEC_PER_MSEC);

                format_timespan(time_string, FORMAT_TIMESPAN_MAX, restart_ms * 1000, MSEC_PER_SEC);

                if (restart_ms > UINT32_MAX) {
                        log_link_error(link, "restart timeout (%s) too big.", time_string);
                        return -ERANGE;
                }

                log_link_debug(link, "Setting restart = %s", time_string);

                r = sd_netlink_message_append_u32(m, IFLA_CAN_RESTART_MS, restart_ms);
                if (r < 0)
                        return log_link_error_errno(link, r, "Could not append IFLA_CAN_RESTART_MS attribute: %m");
        }

        if (link->network->can_triple_sampling >= 0) {
                cm.mask |= CAN_CTRLMODE_3_SAMPLES;
                SET_FLAG(cm.flags, CAN_CTRLMODE_3_SAMPLES, link->network->can_triple_sampling);
                log_link_debug(link, "%sabling triple-sampling", link->network->can_triple_sampling ? "En" : "Dis");
        }

        if (link->network->can_listen_only >= 0) {
                cm.mask |= CAN_CTRLMODE_LISTENONLY;
                SET_FLAG(cm.flags, CAN_CTRLMODE_LISTENONLY, link->network->can_listen_only);
                log_link_debug(link, "%sabling listen-only mode", link->network->can_listen_only ? "En" : "Dis");
        }

        if (cm.mask != 0) {
                r = sd_netlink_message_append_data(m, IFLA_CAN_CTRLMODE, &cm, sizeof(cm));
                if (r < 0)
                        return log_link_error_errno(link, r, "Could not append IFLA_CAN_CTRLMODE attribute: %m");
        }

        if (link->network->can_termination >= 0) {

                log_link_debug(link, "%sabling can-termination", link->network->can_termination ? "En" : "Dis");

                r = sd_netlink_message_append_u16(m, IFLA_CAN_TERMINATION,
                                link->network->can_termination ? CAN_TERMINATION_OHM_VALUE : 0);
                if (r < 0)
                        return log_link_error_errno(link, r, "Could not append IFLA_CAN_TERMINATION attribute: %m");

        }

        r = sd_netlink_message_close_container(m);
        if (r < 0)
                return log_link_error_errno(link, r, "Failed to close netlink container: %m");

        r = sd_netlink_message_close_container(m);
        if (r < 0)
                return log_link_error_errno(link, r, "Failed to close netlink container: %m");

        r = netlink_call_async(link->manager->rtnl, NULL, m, link_set_handler,
                               link_netlink_destroy_callback, link);
        if (r < 0)
                return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");

        link_ref(link);

        if (!(link->flags & IFF_UP))
                return link_up_can(link);

        return 0;
}

static int link_down_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
        int r;

        assert(link);

        if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
                return 1;

        r = sd_netlink_message_get_errno(m);
        if (r < 0) {
                log_link_message_warning_errno(link, m, r, "Could not bring down interface");
                link_enter_failed(link);
                return 1;
        }

        r = link_set_can(link);
        if (r < 0)
                link_enter_failed(link);

        return 1;
}

int link_configure_can(Link *link) {
        int r;

        link_set_state(link, LINK_STATE_CONFIGURING);

        if (streq_ptr(link->kind, "can")) {
                /* The CAN interface must be down to configure bitrate, etc... */
                if ((link->flags & IFF_UP)) {
                        r = link_down(link, link_down_handler);
                        if (r < 0) {
                                link_enter_failed(link);
                                return r;
                        }
                } else {
                        r = link_set_can(link);
                        if (r < 0) {
                                link_enter_failed(link);
                                return r;
                        }
                }

                return 0;
        }

        if (!(link->flags & IFF_UP)) {
                r = link_up_can(link);
                if (r < 0) {
                        link_enter_failed(link);
                        return r;
                }
        }

        return 0;
}
Commit	Line	Data
3ddcbeea YW	1	/* SPDX-License-Identifier: LGPL-2.1+ */
	2
	3	#include <net/if.h>
	4	#include <linux/can/netlink.h>
	5
	6	#include "netlink-util.h"
	7	#include "networkd-can.h"
	8	#include "networkd-link.h"
	9	#include "networkd-manager.h"
74a27268	10	#include "parse-util.h"
3ddcbeea YW	11	#include "string-util.h"
3ddcbeea YW	12
52aa38f1 MR	13	#define CAN_TERMINATION_OHM_VALUE 120
52aa38f1 MR	14
74a27268 RP	15	int config_parse_can_bitrate(
	16	const char* unit,
	17	const char *filename,
	18	unsigned line,
	19	const char *section,
	20	unsigned section_line,
	21	const char *lvalue,
	22	int ltype,
	23	const char *rvalue,
	24	void *data,
	25	void *userdata) {
	26
	27	uint32_t *br = data;
	28	uint64_t sz;
	29	int r;
	30
	31	assert(filename);
	32	assert(lvalue);
	33	assert(rvalue);
	34	assert(data);
	35
	36	r = parse_size(rvalue, 1000, &sz);
	37	if (r < 0) {
	38	log_syntax(unit, LOG_ERR, filename, line, r,
	39	"Failed to parse can bitrate '%s', ignoring: %m", rvalue);
	40	return 0;
	41	}
	42
	43	/* Linux uses __u32 for bitrates, so the value should not exceed that. */
	44	if (sz <= 0 \|\| sz > UINT32_MAX) {
	45	log_syntax(unit, LOG_ERR, filename, line, 0,
	46	"Bit rate out of permitted range 1...4294967295");
	47	return 0;
	48	}
	49
	50	*br = (uint32_t) sz;
	51
	52	return 0;
	53	}
	54
3ddcbeea YW	55	static int link_up_handler(sd_netlink rtnl, sd_netlink_message m, Link *link) {
	56	int r;
	57
	58	assert(link);
	59
	60	if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
	61	return 1;
	62
	63	r = sd_netlink_message_get_errno(m);
	64	if (r < 0)
	65	/* we warn but don't fail the link, as it may be brought up later */
5ecb131d	66	log_link_message_warning_errno(link, m, r, "Could not bring up interface");
3ddcbeea YW	67
	68	return 1;
	69	}
	70
	71	static int link_up_can(Link *link) {
	72	_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
	73	int r;
	74
	75	assert(link);
	76
	77	log_link_debug(link, "Bringing CAN link up");
	78
	79	r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
	80	if (r < 0)
	81	return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
	82
	83	r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
	84	if (r < 0)
	85	return log_link_error_errno(link, r, "Could not set link flags: %m");
	86
	87	r = netlink_call_async(link->manager->rtnl, NULL, req, link_up_handler,
	88	link_netlink_destroy_callback, link);
	89	if (r < 0)
	90	return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
	91
	92	link_ref(link);
	93
	94	return 0;
	95	}
	96
	97	static int link_set_handler(sd_netlink rtnl, sd_netlink_message m, Link *link) {
	98	int r;
	99
	100	assert(link);
	101
	102	log_link_debug(link, "Set link");
	103
	104	r = sd_netlink_message_get_errno(m);
	105	if (r < 0 && r != -EEXIST) {
5ecb131d	106	log_link_message_warning_errno(link, m, r, "Failed to configure CAN link");
3ddcbeea YW	107	link_enter_failed(link);
	108	}
	109
	110	return 1;
	111	}
	112
	113	static int link_set_can(Link *link) {
	114	_cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
74f0fb90	115	struct can_ctrlmode cm = {};
3ddcbeea YW	116	int r;
	117
	118	assert(link);
	119	assert(link->network);
	120	assert(link->manager);
	121	assert(link->manager->rtnl);
	122
	123	log_link_debug(link, "Configuring CAN link.");
	124
	125	r = sd_rtnl_message_new_link(link->manager->rtnl, &m, RTM_NEWLINK, link->ifindex);
	126	if (r < 0)
	127	return log_link_error_errno(link, r, "Failed to allocate netlink message: %m");
	128
	129	r = sd_netlink_message_set_flags(m, NLM_F_REQUEST \| NLM_F_ACK);
	130	if (r < 0)
	131	return log_link_error_errno(link, r, "Could not set netlink flags: %m");
	132
	133	r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
	134	if (r < 0)
	135	return log_link_error_errno(link, r, "Failed to open netlink container: %m");
	136
	137	r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, link->kind);
	138	if (r < 0)
	139	return log_link_error_errno(link, r, "Could not append IFLA_INFO_DATA attribute: %m");
	140
	141	if (link->network->can_bitrate > 0 \|\| link->network->can_sample_point > 0) {
	142	struct can_bittiming bt = {
	143	.bitrate = link->network->can_bitrate,
	144	.sample_point = link->network->can_sample_point,
	145	};
	146
3ddcbeea YW	147	log_link_debug(link, "Setting bitrate = %d bit/s", bt.bitrate);
	148	if (link->network->can_sample_point > 0)
	149	log_link_debug(link, "Setting sample point = %d.%d%%", bt.sample_point / 10, bt.sample_point % 10);
	150	else
	151	log_link_debug(link, "Using default sample point");
	152
	153	r = sd_netlink_message_append_data(m, IFLA_CAN_BITTIMING, &bt, sizeof(bt));
	154	if (r < 0)
	155	return log_link_error_errno(link, r, "Could not append IFLA_CAN_BITTIMING attribute: %m");
	156	}
	157
7e025e9c RP	158	if (link->network->can_data_bitrate > 0 \|\| link->network->can_data_sample_point > 0) {
	159	struct can_bittiming bt = {
	160	.bitrate = link->network->can_data_bitrate,
	161	.sample_point = link->network->can_data_sample_point,
	162	};
	163
	164	log_link_debug(link, "Setting data bitrate = %d bit/s", bt.bitrate);
	165	if (link->network->can_data_sample_point > 0)
	166	log_link_debug(link, "Setting data sample point = %d.%d%%", bt.sample_point / 10, bt.sample_point % 10);
	167	else
	168	log_link_debug(link, "Using default data sample point");
	169
	170	r = sd_netlink_message_append_data(m, IFLA_CAN_DATA_BITTIMING, &bt, sizeof(bt));
	171	if (r < 0)
	172	return log_link_error_errno(link, r, "Could not append IFLA_CAN_DATA_BITTIMING attribute: %m");
	173	}
	174
	175	if (link->network->can_fd_mode >= 0) {
	176	cm.mask \|= CAN_CTRLMODE_FD;
	177	SET_FLAG(cm.flags, CAN_CTRLMODE_FD, link->network->can_fd_mode > 0);
	178	log_link_debug(link, "%sabling FD mode", link->network->can_fd_mode > 0 ? "En" : "Dis");
	179	}
	180
	181	if (link->network->can_non_iso >= 0) {
	182	cm.mask \|= CAN_CTRLMODE_FD_NON_ISO;
	183	SET_FLAG(cm.flags, CAN_CTRLMODE_FD_NON_ISO, link->network->can_non_iso > 0);
	184	log_link_debug(link, "%sabling FD non-ISO mode", link->network->can_non_iso > 0 ? "En" : "Dis");
	185	}
	186
3ddcbeea YW	187	if (link->network->can_restart_us > 0) {
	188	char time_string[FORMAT_TIMESPAN_MAX];
	189	uint64_t restart_ms;
	190
	191	if (link->network->can_restart_us == USEC_INFINITY)
	192	restart_ms = 0;
	193	else
	194	restart_ms = DIV_ROUND_UP(link->network->can_restart_us, USEC_PER_MSEC);
	195
	196	format_timespan(time_string, FORMAT_TIMESPAN_MAX, restart_ms * 1000, MSEC_PER_SEC);
	197
	198	if (restart_ms > UINT32_MAX) {
	199	log_link_error(link, "restart timeout (%s) too big.", time_string);
	200	return -ERANGE;
	201	}
	202
	203	log_link_debug(link, "Setting restart = %s", time_string);
	204
	205	r = sd_netlink_message_append_u32(m, IFLA_CAN_RESTART_MS, restart_ms);
	206	if (r < 0)
	207	return log_link_error_errno(link, r, "Could not append IFLA_CAN_RESTART_MS attribute: %m");
	208	}
	209
	210	if (link->network->can_triple_sampling >= 0) {
74f0fb90 YW	211	cm.mask \|= CAN_CTRLMODE_3_SAMPLES;
74f0fb90 YW	212	SET_FLAG(cm.flags, CAN_CTRLMODE_3_SAMPLES, link->network->can_triple_sampling);
3ddcbeea	213	log_link_debug(link, "%sabling triple-sampling", link->network->can_triple_sampling ? "En" : "Dis");
74f0fb90 YW	214	}
	215
	216	if (link->network->can_listen_only >= 0) {
	217	cm.mask \|= CAN_CTRLMODE_LISTENONLY;
	218	SET_FLAG(cm.flags, CAN_CTRLMODE_LISTENONLY, link->network->can_listen_only);
	219	log_link_debug(link, "%sabling listen-only mode", link->network->can_listen_only ? "En" : "Dis");
	220	}
3ddcbeea	221
74f0fb90	222	if (cm.mask != 0) {
3ddcbeea YW	223	r = sd_netlink_message_append_data(m, IFLA_CAN_CTRLMODE, &cm, sizeof(cm));
	224	if (r < 0)
	225	return log_link_error_errno(link, r, "Could not append IFLA_CAN_CTRLMODE attribute: %m");
	226	}
	227
52aa38f1 MR	228	if (link->network->can_termination >= 0) {
	229
	230	log_link_debug(link, "%sabling can-termination", link->network->can_termination ? "En" : "Dis");
	231
	232	r = sd_netlink_message_append_u16(m, IFLA_CAN_TERMINATION,
	233	link->network->can_termination ? CAN_TERMINATION_OHM_VALUE : 0);
	234	if (r < 0)
	235	return log_link_error_errno(link, r, "Could not append IFLA_CAN_TERMINATION attribute: %m");
	236
	237	}
	238
3ddcbeea YW	239	r = sd_netlink_message_close_container(m);
	240	if (r < 0)
	241	return log_link_error_errno(link, r, "Failed to close netlink container: %m");
	242
	243	r = sd_netlink_message_close_container(m);
	244	if (r < 0)
	245	return log_link_error_errno(link, r, "Failed to close netlink container: %m");
	246
	247	r = netlink_call_async(link->manager->rtnl, NULL, m, link_set_handler,
	248	link_netlink_destroy_callback, link);
	249	if (r < 0)
	250	return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
	251
	252	link_ref(link);
	253
	254	if (!(link->flags & IFF_UP))
	255	return link_up_can(link);
	256
	257	return 0;
	258	}
	259
	260	static int link_down_handler(sd_netlink rtnl, sd_netlink_message m, Link *link) {
	261	int r;
	262
	263	assert(link);
	264
	265	if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
	266	return 1;
	267
	268	r = sd_netlink_message_get_errno(m);
	269	if (r < 0) {
5ecb131d	270	log_link_message_warning_errno(link, m, r, "Could not bring down interface");
3ddcbeea YW	271	link_enter_failed(link);
	272	return 1;
	273	}
	274
	275	r = link_set_can(link);
	276	if (r < 0)
	277	link_enter_failed(link);
	278
	279	return 1;
	280	}
	281
	282	int link_configure_can(Link *link) {
	283	int r;
	284
af9ba57a YW	285	link_set_state(link, LINK_STATE_CONFIGURING);
af9ba57a YW	286
3ddcbeea YW	287	if (streq_ptr(link->kind, "can")) {
	288	/* The CAN interface must be down to configure bitrate, etc... */
	289	if ((link->flags & IFF_UP)) {
	290	r = link_down(link, link_down_handler);
	291	if (r < 0) {
	292	link_enter_failed(link);
	293	return r;
	294	}
	295	} else {
	296	r = link_set_can(link);
	297	if (r < 0) {
	298	link_enter_failed(link);
	299	return r;
	300	}
	301	}
	302
	303	return 0;
	304	}
	305
	306	if (!(link->flags & IFF_UP)) {
	307	r = link_up_can(link);
	308	if (r < 0) {
	309	link_enter_failed(link);
	310	return r;
	311	}
	312	}
	313
	314	return 0;
	315	}