src/network/networkd-can.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   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"
  10 #include "networkd-setlink.h"
  11 #include "parse-util.h"
  12 #include "string-util.h"
  13
  14 #define CAN_TERMINATION_OHM_VALUE 120
  15
  16 int config_parse_can_bitrate(
  17                 const char* unit,
  18                 const char *filename,
  19                 unsigned line,
  20                 const char *section,
  21                 unsigned section_line,
  22                 const char *lvalue,
  23                 int ltype,
  24                 const char *rvalue,
  25                 void *data,
  26                 void *userdata) {
  27
  28         uint32_t *br = data;
  29         uint64_t sz;
  30         int r;
  31
  32         assert(filename);
  33         assert(lvalue);
  34         assert(rvalue);
  35         assert(data);
  36
  37         r = parse_size(rvalue, 1000, &sz);
  38         if (r < 0) {
  39                 log_syntax(unit, LOG_WARNING, filename, line, r,
  40                            "Failed to parse can bitrate '%s', ignoring: %m", rvalue);
  41                 return 0;
  42         }
  43
  44         /* Linux uses __u32 for bitrates, so the value should not exceed that. */
  45         if (sz <= 0 || sz > UINT32_MAX) {
  46                 log_syntax(unit, LOG_WARNING, filename, line, 0,
  47                            "Bit rate out of permitted range 1...4294967295");
  48                 return 0;
  49         }
  50
  51         *br = (uint32_t) sz;
  52
  53         return 0;
  54 }
  55
  56 static int link_set_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
  57         int r;
  58
  59         assert(link);
  60
  61         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
  62                 return 1;
  63
  64         r = sd_netlink_message_get_errno(m);
  65         if (r < 0 && r != -EEXIST) {
  66                 log_link_message_warning_errno(link, m, r, "Failed to configure CAN link");
  67                 link_enter_failed(link);
  68                 return 1;
  69         }
  70
  71         log_link_debug(link, "Link set");
  72
  73         r = link_request_to_activate(link);
  74         if (r < 0) {
  75                 link_enter_failed(link);
  76                 return 1;
  77         }
  78
  79         link->can_configured = true;
  80         link_check_ready(link);
  81
  82         return 1;
  83 }
  84
  85 static int link_set_can(Link *link) {
  86         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *m = NULL;
  87         struct can_ctrlmode cm = {};
  88         int r;
  89
  90         assert(link);
  91         assert(link->network);
  92         assert(link->manager);
  93         assert(link->manager->rtnl);
  94
  95         log_link_debug(link, "Configuring CAN link.");
  96
  97         r = sd_rtnl_message_new_link(link->manager->rtnl, &m, RTM_NEWLINK, link->ifindex);
  98         if (r < 0)
  99                 return log_link_error_errno(link, r, "Failed to allocate netlink message: %m");
 100
 101         r = sd_netlink_message_set_flags(m, NLM_F_REQUEST | NLM_F_ACK);
 102         if (r < 0)
 103                 return log_link_error_errno(link, r, "Could not set netlink flags: %m");
 104
 105         r = sd_netlink_message_open_container(m, IFLA_LINKINFO);
 106         if (r < 0)
 107                 return log_link_error_errno(link, r, "Failed to open netlink container: %m");
 108
 109         r = sd_netlink_message_open_container_union(m, IFLA_INFO_DATA, link->kind);
 110         if (r < 0)
 111                 return log_link_error_errno(link, r, "Could not append IFLA_INFO_DATA attribute: %m");
 112
 113         if (link->network->can_bitrate > 0 || link->network->can_sample_point > 0) {
 114                 struct can_bittiming bt = {
 115                         .bitrate = link->network->can_bitrate,
 116                         .sample_point = link->network->can_sample_point,
 117                 };
 118
 119                 log_link_debug(link, "Setting bitrate = %d bit/s", bt.bitrate);
 120                 if (link->network->can_sample_point > 0)
 121                         log_link_debug(link, "Setting sample point = %d.%d%%", bt.sample_point / 10, bt.sample_point % 10);
 122                 else
 123                         log_link_debug(link, "Using default sample point");
 124
 125                 r = sd_netlink_message_append_data(m, IFLA_CAN_BITTIMING, &bt, sizeof(bt));
 126                 if (r < 0)
 127                         return log_link_error_errno(link, r, "Could not append IFLA_CAN_BITTIMING attribute: %m");
 128         }
 129
 130         if (link->network->can_data_bitrate > 0 || link->network->can_data_sample_point > 0) {
 131                 struct can_bittiming bt = {
 132                         .bitrate = link->network->can_data_bitrate,
 133                         .sample_point = link->network->can_data_sample_point,
 134                 };
 135
 136                 log_link_debug(link, "Setting data bitrate = %d bit/s", bt.bitrate);
 137                 if (link->network->can_data_sample_point > 0)
 138                         log_link_debug(link, "Setting data sample point = %d.%d%%", bt.sample_point / 10, bt.sample_point % 10);
 139                 else
 140                         log_link_debug(link, "Using default data sample point");
 141
 142                 r = sd_netlink_message_append_data(m, IFLA_CAN_DATA_BITTIMING, &bt, sizeof(bt));
 143                 if (r < 0)
 144                         return log_link_error_errno(link, r, "Could not append IFLA_CAN_DATA_BITTIMING attribute: %m");
 145         }
 146
 147         if (link->network->can_fd_mode >= 0) {
 148                 cm.mask |= CAN_CTRLMODE_FD;
 149                 SET_FLAG(cm.flags, CAN_CTRLMODE_FD, link->network->can_fd_mode);
 150                 log_link_debug(link, "Setting FD mode to '%s'.", yes_no(link->network->can_fd_mode));
 151         }
 152
 153         if (link->network->can_non_iso >= 0) {
 154                 cm.mask |= CAN_CTRLMODE_FD_NON_ISO;
 155                 SET_FLAG(cm.flags, CAN_CTRLMODE_FD_NON_ISO, link->network->can_non_iso);
 156                 log_link_debug(link, "Setting FD non-ISO mode to '%s'.", yes_no(link->network->can_non_iso));
 157         }
 158
 159         if (link->network->can_restart_us > 0) {
 160                 char time_string[FORMAT_TIMESPAN_MAX];
 161                 uint64_t restart_ms;
 162
 163                 if (link->network->can_restart_us == USEC_INFINITY)
 164                         restart_ms = 0;
 165                 else
 166                         restart_ms = DIV_ROUND_UP(link->network->can_restart_us, USEC_PER_MSEC);
 167
 168                 format_timespan(time_string, FORMAT_TIMESPAN_MAX, restart_ms * 1000, MSEC_PER_SEC);
 169
 170                 if (restart_ms > UINT32_MAX)
 171                         return log_link_error_errno(link, SYNTHETIC_ERRNO(ERANGE), "restart timeout (%s) too big.", time_string);
 172
 173                 log_link_debug(link, "Setting restart = %s", time_string);
 174
 175                 r = sd_netlink_message_append_u32(m, IFLA_CAN_RESTART_MS, restart_ms);
 176                 if (r < 0)
 177                         return log_link_error_errno(link, r, "Could not append IFLA_CAN_RESTART_MS attribute: %m");
 178         }
 179
 180         if (link->network->can_triple_sampling >= 0) {
 181                 cm.mask |= CAN_CTRLMODE_3_SAMPLES;
 182                 SET_FLAG(cm.flags, CAN_CTRLMODE_3_SAMPLES, link->network->can_triple_sampling);
 183                 log_link_debug(link, "Setting triple-sampling to '%s'.", yes_no(link->network->can_triple_sampling));
 184         }
 185
 186         if (link->network->can_berr_reporting >= 0) {
 187                 cm.mask |= CAN_CTRLMODE_BERR_REPORTING;
 188                 SET_FLAG(cm.flags, CAN_CTRLMODE_BERR_REPORTING, link->network->can_berr_reporting);
 189                 log_link_debug(link, "Setting bus error reporting to '%s'.", yes_no(link->network->can_berr_reporting));
 190         }
 191
 192         if (link->network->can_listen_only >= 0) {
 193                 cm.mask |= CAN_CTRLMODE_LISTENONLY;
 194                 SET_FLAG(cm.flags, CAN_CTRLMODE_LISTENONLY, link->network->can_listen_only);
 195                 log_link_debug(link, "Setting listen-only mode to '%s'.", yes_no(link->network->can_listen_only));
 196         }
 197
 198         if (cm.mask != 0) {
 199                 r = sd_netlink_message_append_data(m, IFLA_CAN_CTRLMODE, &cm, sizeof(cm));
 200                 if (r < 0)
 201                         return log_link_error_errno(link, r, "Could not append IFLA_CAN_CTRLMODE attribute: %m");
 202         }
 203
 204         if (link->network->can_termination >= 0) {
 205
 206                 log_link_debug(link, "Setting can-termination to '%s'.", yes_no(link->network->can_termination));
 207
 208                 r = sd_netlink_message_append_u16(m, IFLA_CAN_TERMINATION,
 209                                 link->network->can_termination ? CAN_TERMINATION_OHM_VALUE : 0);
 210                 if (r < 0)
 211                         return log_link_error_errno(link, r, "Could not append IFLA_CAN_TERMINATION attribute: %m");
 212
 213         }
 214
 215         r = sd_netlink_message_close_container(m);
 216         if (r < 0)
 217                 return log_link_error_errno(link, r, "Failed to close netlink container: %m");
 218
 219         r = sd_netlink_message_close_container(m);
 220         if (r < 0)
 221                 return log_link_error_errno(link, r, "Failed to close netlink container: %m");
 222
 223         r = netlink_call_async(link->manager->rtnl, NULL, m, link_set_handler,
 224                                link_netlink_destroy_callback, link);
 225         if (r < 0)
 226                 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
 227
 228         link_ref(link);
 229
 230         return 0;
 231 }
 232
 233 int link_configure_can(Link *link) {
 234         int r;
 235
 236         link_set_state(link, LINK_STATE_CONFIGURING);
 237
 238         if (streq_ptr(link->kind, "can")) {
 239                 /* The CAN interface must be down to configure bitrate, etc... */
 240                 if (link->flags & IFF_UP) {
 241                         r = link_down(link);
 242                         if (r < 0)
 243                                 return r;
 244                 }
 245
 246                 return link_set_can(link);
 247         }
 248
 249         r = link_request_to_activate(link);
 250         if (r < 0)
 251                 return r;
 252
 253         link->can_configured = true;
 254         link_check_ready(link);
 255
 256         return 0;
 257 }