1 /* 2 * net/tipc/eth_media.c: Ethernet bearer support for TIPC 3 * 4 * Copyright (c) 2001-2007, Ericsson AB 5 * Copyright (c) 2005-2008, 2011, Wind River Systems 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the names of the copyright holders nor the names of its 17 * contributors may be used to endorse or promote products derived from 18 * this software without specific prior written permission. 19 * 20 * Alternatively, this software may be distributed under the terms of the 21 * GNU General Public License ("GPL") version 2 as published by the Free 22 * Software Foundation. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 28 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 34 * POSSIBILITY OF SUCH DAMAGE. 35 */ 36 37 #include "core.h" 38 #include "bearer.h" 39 40 #define MAX_ETH_BEARERS MAX_BEARERS 41 42 #define ETH_ADDR_OFFSET 4 /* message header offset of MAC address */ 43 44 /** 45 * struct eth_bearer - Ethernet bearer data structure 46 * @bearer: ptr to associated "generic" bearer structure 47 * @dev: ptr to associated Ethernet network device 48 * @tipc_packet_type: used in binding TIPC to Ethernet driver 49 * @setup: work item used when enabling bearer 50 * @cleanup: work item used when disabling bearer 51 */ 52 struct eth_bearer { 53 struct tipc_bearer *bearer; 54 struct net_device *dev; 55 struct packet_type tipc_packet_type; 56 struct work_struct setup; 57 struct work_struct cleanup; 58 }; 59 60 static struct tipc_media eth_media_info; 61 static struct eth_bearer eth_bearers[MAX_ETH_BEARERS]; 62 static int eth_started; 63 64 static int recv_notification(struct notifier_block *nb, unsigned long evt, 65 void *dv); 66 /* 67 * Network device notifier info 68 */ 69 static struct notifier_block notifier = { 70 .notifier_call = recv_notification, 71 .priority = 0 72 }; 73 74 /** 75 * eth_media_addr_set - initialize Ethernet media address structure 76 * 77 * Media-dependent "value" field stores MAC address in first 6 bytes 78 * and zeroes out the remaining bytes. 79 */ 80 static void eth_media_addr_set(struct tipc_media_addr *a, char *mac) 81 { 82 memcpy(a->value, mac, ETH_ALEN); 83 memset(a->value + ETH_ALEN, 0, sizeof(a->value) - ETH_ALEN); 84 a->media_id = TIPC_MEDIA_TYPE_ETH; 85 a->broadcast = !memcmp(mac, eth_media_info.bcast_addr.value, ETH_ALEN); 86 } 87 88 /** 89 * send_msg - send a TIPC message out over an Ethernet interface 90 */ 91 static int send_msg(struct sk_buff *buf, struct tipc_bearer *tb_ptr, 92 struct tipc_media_addr *dest) 93 { 94 struct sk_buff *clone; 95 struct net_device *dev; 96 int delta; 97 98 clone = skb_clone(buf, GFP_ATOMIC); 99 if (!clone) 100 return 0; 101 102 dev = ((struct eth_bearer *)(tb_ptr->usr_handle))->dev; 103 delta = dev->hard_header_len - skb_headroom(buf); 104 105 if ((delta > 0) && 106 pskb_expand_head(clone, SKB_DATA_ALIGN(delta), 0, GFP_ATOMIC)) { 107 kfree_skb(clone); 108 return 0; 109 } 110 111 skb_reset_network_header(clone); 112 clone->dev = dev; 113 dev_hard_header(clone, dev, ETH_P_TIPC, dest->value, 114 dev->dev_addr, clone->len); 115 dev_queue_xmit(clone); 116 return 0; 117 } 118 119 /** 120 * recv_msg - handle incoming TIPC message from an Ethernet interface 121 * 122 * Accept only packets explicitly sent to this node, or broadcast packets; 123 * ignores packets sent using Ethernet multicast, and traffic sent to other 124 * nodes (which can happen if interface is running in promiscuous mode). 125 */ 126 static int recv_msg(struct sk_buff *buf, struct net_device *dev, 127 struct packet_type *pt, struct net_device *orig_dev) 128 { 129 struct eth_bearer *eb_ptr = (struct eth_bearer *)pt->af_packet_priv; 130 131 if (!net_eq(dev_net(dev), &init_net)) { 132 kfree_skb(buf); 133 return 0; 134 } 135 136 if (likely(eb_ptr->bearer)) { 137 if (likely(buf->pkt_type <= PACKET_BROADCAST)) { 138 buf->next = NULL; 139 tipc_recv_msg(buf, eb_ptr->bearer); 140 return 0; 141 } 142 } 143 kfree_skb(buf); 144 return 0; 145 } 146 147 /** 148 * setup_bearer - setup association between Ethernet bearer and interface 149 */ 150 static void setup_bearer(struct work_struct *work) 151 { 152 struct eth_bearer *eb_ptr = 153 container_of(work, struct eth_bearer, setup); 154 155 dev_add_pack(&eb_ptr->tipc_packet_type); 156 } 157 158 /** 159 * enable_bearer - attach TIPC bearer to an Ethernet interface 160 */ 161 static int enable_bearer(struct tipc_bearer *tb_ptr) 162 { 163 struct net_device *dev = NULL; 164 struct net_device *pdev = NULL; 165 struct eth_bearer *eb_ptr = ð_bearers[0]; 166 struct eth_bearer *stop = ð_bearers[MAX_ETH_BEARERS]; 167 char *driver_name = strchr((const char *)tb_ptr->name, ':') + 1; 168 int pending_dev = 0; 169 170 /* Find unused Ethernet bearer structure */ 171 while (eb_ptr->dev) { 172 if (!eb_ptr->bearer) 173 pending_dev++; 174 if (++eb_ptr == stop) 175 return pending_dev ? -EAGAIN : -EDQUOT; 176 } 177 178 /* Find device with specified name */ 179 read_lock(&dev_base_lock); 180 for_each_netdev(&init_net, pdev) { 181 if (!strncmp(pdev->name, driver_name, IFNAMSIZ)) { 182 dev = pdev; 183 dev_hold(dev); 184 break; 185 } 186 } 187 read_unlock(&dev_base_lock); 188 if (!dev) 189 return -ENODEV; 190 191 /* Create Ethernet bearer for device */ 192 eb_ptr->dev = dev; 193 eb_ptr->tipc_packet_type.type = htons(ETH_P_TIPC); 194 eb_ptr->tipc_packet_type.dev = dev; 195 eb_ptr->tipc_packet_type.func = recv_msg; 196 eb_ptr->tipc_packet_type.af_packet_priv = eb_ptr; 197 INIT_LIST_HEAD(&(eb_ptr->tipc_packet_type.list)); 198 INIT_WORK(&eb_ptr->setup, setup_bearer); 199 schedule_work(&eb_ptr->setup); 200 201 /* Associate TIPC bearer with Ethernet bearer */ 202 eb_ptr->bearer = tb_ptr; 203 tb_ptr->usr_handle = (void *)eb_ptr; 204 tb_ptr->mtu = dev->mtu; 205 tb_ptr->blocked = 0; 206 eth_media_addr_set(&tb_ptr->addr, (char *)dev->dev_addr); 207 return 0; 208 } 209 210 /** 211 * cleanup_bearer - break association between Ethernet bearer and interface 212 * 213 * This routine must be invoked from a work queue because it can sleep. 214 */ 215 static void cleanup_bearer(struct work_struct *work) 216 { 217 struct eth_bearer *eb_ptr = 218 container_of(work, struct eth_bearer, cleanup); 219 220 dev_remove_pack(&eb_ptr->tipc_packet_type); 221 dev_put(eb_ptr->dev); 222 eb_ptr->dev = NULL; 223 } 224 225 /** 226 * disable_bearer - detach TIPC bearer from an Ethernet interface 227 * 228 * Mark Ethernet bearer as inactive so that incoming buffers are thrown away, 229 * then get worker thread to complete bearer cleanup. (Can't do cleanup 230 * here because cleanup code needs to sleep and caller holds spinlocks.) 231 */ 232 static void disable_bearer(struct tipc_bearer *tb_ptr) 233 { 234 struct eth_bearer *eb_ptr = (struct eth_bearer *)tb_ptr->usr_handle; 235 236 eb_ptr->bearer = NULL; 237 INIT_WORK(&eb_ptr->cleanup, cleanup_bearer); 238 schedule_work(&eb_ptr->cleanup); 239 } 240 241 /** 242 * recv_notification - handle device updates from OS 243 * 244 * Change the state of the Ethernet bearer (if any) associated with the 245 * specified device. 246 */ 247 static int recv_notification(struct notifier_block *nb, unsigned long evt, 248 void *dv) 249 { 250 struct net_device *dev = (struct net_device *)dv; 251 struct eth_bearer *eb_ptr = ð_bearers[0]; 252 struct eth_bearer *stop = ð_bearers[MAX_ETH_BEARERS]; 253 254 if (!net_eq(dev_net(dev), &init_net)) 255 return NOTIFY_DONE; 256 257 while ((eb_ptr->dev != dev)) { 258 if (++eb_ptr == stop) 259 return NOTIFY_DONE; /* couldn't find device */ 260 } 261 if (!eb_ptr->bearer) 262 return NOTIFY_DONE; /* bearer had been disabled */ 263 264 eb_ptr->bearer->mtu = dev->mtu; 265 266 switch (evt) { 267 case NETDEV_CHANGE: 268 if (netif_carrier_ok(dev)) 269 tipc_continue(eb_ptr->bearer); 270 else 271 tipc_block_bearer(eb_ptr->bearer->name); 272 break; 273 case NETDEV_UP: 274 tipc_continue(eb_ptr->bearer); 275 break; 276 case NETDEV_DOWN: 277 tipc_block_bearer(eb_ptr->bearer->name); 278 break; 279 case NETDEV_CHANGEMTU: 280 case NETDEV_CHANGEADDR: 281 tipc_block_bearer(eb_ptr->bearer->name); 282 tipc_continue(eb_ptr->bearer); 283 break; 284 case NETDEV_UNREGISTER: 285 case NETDEV_CHANGENAME: 286 tipc_disable_bearer(eb_ptr->bearer->name); 287 break; 288 } 289 return NOTIFY_OK; 290 } 291 292 /** 293 * eth_addr2str - convert Ethernet address to string 294 */ 295 static int eth_addr2str(struct tipc_media_addr *a, char *str_buf, int str_size) 296 { 297 if (str_size < 18) /* 18 = strlen("aa:bb:cc:dd:ee:ff\0") */ 298 return 1; 299 300 sprintf(str_buf, "%pM", a->value); 301 return 0; 302 } 303 304 /** 305 * eth_str2addr - convert string to Ethernet address 306 */ 307 static int eth_str2addr(struct tipc_media_addr *a, char *str_buf) 308 { 309 char mac[ETH_ALEN]; 310 int r; 311 312 r = sscanf(str_buf, "%02x:%02x:%02x:%02x:%02x:%02x", 313 (u32 *)&mac[0], (u32 *)&mac[1], (u32 *)&mac[2], 314 (u32 *)&mac[3], (u32 *)&mac[4], (u32 *)&mac[5]); 315 316 if (r != ETH_ALEN) 317 return 1; 318 319 eth_media_addr_set(a, mac); 320 return 0; 321 } 322 323 /** 324 * eth_str2addr - convert Ethernet address format to message header format 325 */ 326 static int eth_addr2msg(struct tipc_media_addr *a, char *msg_area) 327 { 328 memset(msg_area, 0, TIPC_MEDIA_ADDR_SIZE); 329 msg_area[TIPC_MEDIA_TYPE_OFFSET] = TIPC_MEDIA_TYPE_ETH; 330 memcpy(msg_area + ETH_ADDR_OFFSET, a->value, ETH_ALEN); 331 return 0; 332 } 333 334 /** 335 * eth_str2addr - convert message header address format to Ethernet format 336 */ 337 static int eth_msg2addr(struct tipc_media_addr *a, char *msg_area) 338 { 339 if (msg_area[TIPC_MEDIA_TYPE_OFFSET] != TIPC_MEDIA_TYPE_ETH) 340 return 1; 341 342 eth_media_addr_set(a, msg_area + ETH_ADDR_OFFSET); 343 return 0; 344 } 345 346 /* 347 * Ethernet media registration info 348 */ 349 static struct tipc_media eth_media_info = { 350 .send_msg = send_msg, 351 .enable_bearer = enable_bearer, 352 .disable_bearer = disable_bearer, 353 .addr2str = eth_addr2str, 354 .str2addr = eth_str2addr, 355 .addr2msg = eth_addr2msg, 356 .msg2addr = eth_msg2addr, 357 .bcast_addr = { { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, 358 TIPC_MEDIA_TYPE_ETH, 1 }, 359 .priority = TIPC_DEF_LINK_PRI, 360 .tolerance = TIPC_DEF_LINK_TOL, 361 .window = TIPC_DEF_LINK_WIN, 362 .type_id = TIPC_MEDIA_TYPE_ETH, 363 .name = "eth" 364 }; 365 366 /** 367 * tipc_eth_media_start - activate Ethernet bearer support 368 * 369 * Register Ethernet media type with TIPC bearer code. Also register 370 * with OS for notifications about device state changes. 371 */ 372 int tipc_eth_media_start(void) 373 { 374 int res; 375 376 if (eth_started) 377 return -EINVAL; 378 379 res = tipc_register_media(ð_media_info); 380 if (res) 381 return res; 382 383 res = register_netdevice_notifier(¬ifier); 384 if (!res) 385 eth_started = 1; 386 return res; 387 } 388 389 /** 390 * tipc_eth_media_stop - deactivate Ethernet bearer support 391 */ 392 void tipc_eth_media_stop(void) 393 { 394 if (!eth_started) 395 return; 396 397 flush_scheduled_work(); 398 unregister_netdevice_notifier(¬ifier); 399 eth_started = 0; 400 } 401