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 * @cleanup: work item used when disabling bearer 50 */ 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 cleanup; 57 }; 58 59 static struct tipc_media eth_media_info; 60 static struct eth_bearer eth_bearers[MAX_ETH_BEARERS]; 61 static int eth_started; 62 static struct notifier_block notifier; 63 64 /** 65 * eth_media_addr_set - initialize Ethernet media address structure 66 * 67 * Media-dependent "value" field stores MAC address in first 6 bytes 68 * and zeroes out the remaining bytes. 69 */ 70 71 static void eth_media_addr_set(struct tipc_media_addr *a, char *mac) 72 { 73 memcpy(a->value, mac, ETH_ALEN); 74 memset(a->value + ETH_ALEN, 0, sizeof(a->value) - ETH_ALEN); 75 a->media_id = TIPC_MEDIA_TYPE_ETH; 76 a->broadcast = !memcmp(mac, eth_media_info.bcast_addr.value, ETH_ALEN); 77 } 78 79 /** 80 * send_msg - send a TIPC message out over an Ethernet interface 81 */ 82 83 static int send_msg(struct sk_buff *buf, struct tipc_bearer *tb_ptr, 84 struct tipc_media_addr *dest) 85 { 86 struct sk_buff *clone; 87 struct net_device *dev; 88 int delta; 89 90 clone = skb_clone(buf, GFP_ATOMIC); 91 if (!clone) 92 return 0; 93 94 dev = ((struct eth_bearer *)(tb_ptr->usr_handle))->dev; 95 delta = dev->hard_header_len - skb_headroom(buf); 96 97 if ((delta > 0) && 98 pskb_expand_head(clone, SKB_DATA_ALIGN(delta), 0, GFP_ATOMIC)) { 99 kfree_skb(clone); 100 return 0; 101 } 102 103 skb_reset_network_header(clone); 104 clone->dev = dev; 105 dev_hard_header(clone, dev, ETH_P_TIPC, dest->value, 106 dev->dev_addr, clone->len); 107 dev_queue_xmit(clone); 108 return 0; 109 } 110 111 /** 112 * recv_msg - handle incoming TIPC message from an Ethernet interface 113 * 114 * Accept only packets explicitly sent to this node, or broadcast packets; 115 * ignores packets sent using Ethernet multicast, and traffic sent to other 116 * nodes (which can happen if interface is running in promiscuous mode). 117 */ 118 119 static int recv_msg(struct sk_buff *buf, struct net_device *dev, 120 struct packet_type *pt, struct net_device *orig_dev) 121 { 122 struct eth_bearer *eb_ptr = (struct eth_bearer *)pt->af_packet_priv; 123 124 if (!net_eq(dev_net(dev), &init_net)) { 125 kfree_skb(buf); 126 return 0; 127 } 128 129 if (likely(eb_ptr->bearer)) { 130 if (likely(buf->pkt_type <= PACKET_BROADCAST)) { 131 buf->next = NULL; 132 tipc_recv_msg(buf, eb_ptr->bearer); 133 return 0; 134 } 135 } 136 kfree_skb(buf); 137 return 0; 138 } 139 140 /** 141 * enable_bearer - attach TIPC bearer to an Ethernet interface 142 */ 143 144 static int enable_bearer(struct tipc_bearer *tb_ptr) 145 { 146 struct net_device *dev = NULL; 147 struct net_device *pdev = NULL; 148 struct eth_bearer *eb_ptr = ð_bearers[0]; 149 struct eth_bearer *stop = ð_bearers[MAX_ETH_BEARERS]; 150 char *driver_name = strchr((const char *)tb_ptr->name, ':') + 1; 151 int pending_dev = 0; 152 153 /* Find unused Ethernet bearer structure */ 154 155 while (eb_ptr->dev) { 156 if (!eb_ptr->bearer) 157 pending_dev++; 158 if (++eb_ptr == stop) 159 return pending_dev ? -EAGAIN : -EDQUOT; 160 } 161 162 /* Find device with specified name */ 163 164 read_lock(&dev_base_lock); 165 for_each_netdev(&init_net, pdev) { 166 if (!strncmp(pdev->name, driver_name, IFNAMSIZ)) { 167 dev = pdev; 168 dev_hold(dev); 169 break; 170 } 171 } 172 read_unlock(&dev_base_lock); 173 if (!dev) 174 return -ENODEV; 175 176 /* Create Ethernet bearer for device */ 177 178 eb_ptr->dev = dev; 179 eb_ptr->tipc_packet_type.type = htons(ETH_P_TIPC); 180 eb_ptr->tipc_packet_type.dev = dev; 181 eb_ptr->tipc_packet_type.func = recv_msg; 182 eb_ptr->tipc_packet_type.af_packet_priv = eb_ptr; 183 INIT_LIST_HEAD(&(eb_ptr->tipc_packet_type.list)); 184 dev_add_pack(&eb_ptr->tipc_packet_type); 185 186 /* Associate TIPC bearer with Ethernet bearer */ 187 188 eb_ptr->bearer = tb_ptr; 189 tb_ptr->usr_handle = (void *)eb_ptr; 190 tb_ptr->mtu = dev->mtu; 191 tb_ptr->blocked = 0; 192 eth_media_addr_set(&tb_ptr->addr, (char *)dev->dev_addr); 193 return 0; 194 } 195 196 /** 197 * cleanup_bearer - break association between Ethernet bearer and interface 198 * 199 * This routine must be invoked from a work queue because it can sleep. 200 */ 201 202 static void cleanup_bearer(struct work_struct *work) 203 { 204 struct eth_bearer *eb_ptr = 205 container_of(work, struct eth_bearer, cleanup); 206 207 dev_remove_pack(&eb_ptr->tipc_packet_type); 208 dev_put(eb_ptr->dev); 209 eb_ptr->dev = NULL; 210 } 211 212 /** 213 * disable_bearer - detach TIPC bearer from an Ethernet interface 214 * 215 * Mark Ethernet bearer as inactive so that incoming buffers are thrown away, 216 * then get worker thread to complete bearer cleanup. (Can't do cleanup 217 * here because cleanup code needs to sleep and caller holds spinlocks.) 218 */ 219 220 static void disable_bearer(struct tipc_bearer *tb_ptr) 221 { 222 struct eth_bearer *eb_ptr = (struct eth_bearer *)tb_ptr->usr_handle; 223 224 eb_ptr->bearer = NULL; 225 INIT_WORK(&eb_ptr->cleanup, cleanup_bearer); 226 schedule_work(&eb_ptr->cleanup); 227 } 228 229 /** 230 * recv_notification - handle device updates from OS 231 * 232 * Change the state of the Ethernet bearer (if any) associated with the 233 * specified device. 234 */ 235 236 static int recv_notification(struct notifier_block *nb, unsigned long evt, 237 void *dv) 238 { 239 struct net_device *dev = (struct net_device *)dv; 240 struct eth_bearer *eb_ptr = ð_bearers[0]; 241 struct eth_bearer *stop = ð_bearers[MAX_ETH_BEARERS]; 242 243 if (!net_eq(dev_net(dev), &init_net)) 244 return NOTIFY_DONE; 245 246 while ((eb_ptr->dev != dev)) { 247 if (++eb_ptr == stop) 248 return NOTIFY_DONE; /* couldn't find device */ 249 } 250 if (!eb_ptr->bearer) 251 return NOTIFY_DONE; /* bearer had been disabled */ 252 253 eb_ptr->bearer->mtu = dev->mtu; 254 255 switch (evt) { 256 case NETDEV_CHANGE: 257 if (netif_carrier_ok(dev)) 258 tipc_continue(eb_ptr->bearer); 259 else 260 tipc_block_bearer(eb_ptr->bearer->name); 261 break; 262 case NETDEV_UP: 263 tipc_continue(eb_ptr->bearer); 264 break; 265 case NETDEV_DOWN: 266 tipc_block_bearer(eb_ptr->bearer->name); 267 break; 268 case NETDEV_CHANGEMTU: 269 case NETDEV_CHANGEADDR: 270 tipc_block_bearer(eb_ptr->bearer->name); 271 tipc_continue(eb_ptr->bearer); 272 break; 273 case NETDEV_UNREGISTER: 274 case NETDEV_CHANGENAME: 275 tipc_disable_bearer(eb_ptr->bearer->name); 276 break; 277 } 278 return NOTIFY_OK; 279 } 280 281 /** 282 * eth_addr2str - convert Ethernet address to string 283 */ 284 285 static int eth_addr2str(struct tipc_media_addr *a, char *str_buf, int str_size) 286 { 287 if (str_size < 18) /* 18 = strlen("aa:bb:cc:dd:ee:ff\0") */ 288 return 1; 289 290 sprintf(str_buf, "%pM", a->value); 291 return 0; 292 } 293 294 /** 295 * eth_str2addr - convert string to Ethernet address 296 */ 297 298 static int eth_str2addr(struct tipc_media_addr *a, char *str_buf) 299 { 300 char mac[ETH_ALEN]; 301 int r; 302 303 r = sscanf(str_buf, "%02x:%02x:%02x:%02x:%02x:%02x", 304 (u32 *)&mac[0], (u32 *)&mac[1], (u32 *)&mac[2], 305 (u32 *)&mac[3], (u32 *)&mac[4], (u32 *)&mac[5]); 306 307 if (r != ETH_ALEN) 308 return 1; 309 310 eth_media_addr_set(a, mac); 311 return 0; 312 } 313 314 /** 315 * eth_str2addr - convert Ethernet address format to message header format 316 */ 317 318 static int eth_addr2msg(struct tipc_media_addr *a, char *msg_area) 319 { 320 memset(msg_area, 0, TIPC_MEDIA_ADDR_SIZE); 321 msg_area[TIPC_MEDIA_TYPE_OFFSET] = TIPC_MEDIA_TYPE_ETH; 322 memcpy(msg_area + ETH_ADDR_OFFSET, a->value, ETH_ALEN); 323 return 0; 324 } 325 326 /** 327 * eth_str2addr - convert message header address format to Ethernet format 328 */ 329 330 static int eth_msg2addr(struct tipc_media_addr *a, char *msg_area) 331 { 332 if (msg_area[TIPC_MEDIA_TYPE_OFFSET] != TIPC_MEDIA_TYPE_ETH) 333 return 1; 334 335 eth_media_addr_set(a, msg_area + ETH_ADDR_OFFSET); 336 return 0; 337 } 338 339 /* 340 * Ethernet media registration info 341 */ 342 343 static struct tipc_media eth_media_info = { 344 .send_msg = send_msg, 345 .enable_bearer = enable_bearer, 346 .disable_bearer = disable_bearer, 347 .addr2str = eth_addr2str, 348 .str2addr = eth_str2addr, 349 .addr2msg = eth_addr2msg, 350 .msg2addr = eth_msg2addr, 351 .bcast_addr = { { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }, 352 TIPC_MEDIA_TYPE_ETH, 1 }, 353 .priority = TIPC_DEF_LINK_PRI, 354 .tolerance = TIPC_DEF_LINK_TOL, 355 .window = TIPC_DEF_LINK_WIN, 356 .type_id = TIPC_MEDIA_TYPE_ETH, 357 .name = "eth" 358 }; 359 360 /** 361 * tipc_eth_media_start - activate Ethernet bearer support 362 * 363 * Register Ethernet media type with TIPC bearer code. Also register 364 * with OS for notifications about device state changes. 365 */ 366 367 int tipc_eth_media_start(void) 368 { 369 int res; 370 371 if (eth_started) 372 return -EINVAL; 373 374 res = tipc_register_media(ð_media_info); 375 if (res) 376 return res; 377 378 notifier.notifier_call = &recv_notification; 379 notifier.priority = 0; 380 res = register_netdevice_notifier(¬ifier); 381 if (!res) 382 eth_started = 1; 383 return res; 384 } 385 386 /** 387 * tipc_eth_media_stop - deactivate Ethernet bearer support 388 */ 389 390 void tipc_eth_media_stop(void) 391 { 392 if (!eth_started) 393 return; 394 395 flush_scheduled_work(); 396 unregister_netdevice_notifier(¬ifier); 397 eth_started = 0; 398 } 399