Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit e4d050cbf7720d8bcc781f4ef557d37ed148a5c4

Authored by Ying Xue
Committed by David S. Miller
1 parent 6e967adf79
Exists in smarc-imx_3.14.28_1.0.0_ga and in 1 other branch imx_3.14.28_1.0.0_ga

tipc: eliminate code duplication in media layer 

Currently TIPC supports two L2 media types, Ethernet and Infiniband.
Because both these media are accessed through the common net_device API,
several functions in the two media adaptation files turn out to be
fully or almost identical, leading to unnecessary code duplication.

In this commit we extract this common code from the two media files
and move them to the generic bearer.c. Additionally, we change
the function names to reflect their real role: to access L2 media,
irrespective of type.

Signed-off-by: Ying Xue <ying.xue@windriver.com>
Cc: Patrick McHardy <kaber@trash.net>
Reviewed-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Signed-off-by: Jon Maloy <jon.maloy@ericsson.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

Showing 4 changed files with 149 additions and 231 deletions Side-by-side Diff

... ... @@ -2,7 +2,7 @@
2 2 * net/tipc/bearer.c: TIPC bearer code
3 3 *
4 4 * Copyright (c) 1996-2006, 2013, Ericsson AB
5   - * Copyright (c) 2004-2006, 2010-2011, Wind River Systems
  5 + * Copyright (c) 2004-2006, 2010-2013, Wind River Systems
6 6 * All rights reserved.
7 7 *
8 8 * Redistribution and use in source and binary forms, with or without
... ... @@ -332,6 +332,7 @@
332 332  
333 333 b_ptr = &tipc_bearers[bearer_id];
334 334 strcpy(b_ptr->name, name);
  335 + b_ptr->media = m_ptr;
335 336 res = m_ptr->enable_media(b_ptr);
336 337 if (res) {
337 338 pr_warn("Bearer <%s> rejected, enable failure (%d)\n",
... ... @@ -340,7 +341,6 @@
340 341 }
341 342  
342 343 b_ptr->identity = bearer_id;
343   - b_ptr->media = m_ptr;
344 344 b_ptr->tolerance = m_ptr->tolerance;
345 345 b_ptr->window = m_ptr->window;
346 346 b_ptr->net_plane = bearer_id + 'A';
... ... @@ -430,6 +430,108 @@
430 430 }
431 431 write_unlock_bh(&tipc_net_lock);
432 432 return res;
  433 +}
  434 +
  435 +
  436 +/* tipc_l2_media_addr_set - initialize Ethernet media address structure
  437 + *
  438 + * Media-dependent "value" field stores MAC address in first 6 bytes
  439 + * and zeroes out the remaining bytes.
  440 + */
  441 +void tipc_l2_media_addr_set(const struct tipc_bearer *b,
  442 + struct tipc_media_addr *a, char *mac)
  443 +{
  444 + int len = b->media->hwaddr_len;
  445 +
  446 + if (unlikely(sizeof(a->value) < len)) {
  447 + WARN_ONCE(1, "Media length invalid\n");
  448 + return;
  449 + }
  450 +
  451 + memcpy(a->value, mac, len);
  452 + memset(a->value + len, 0, sizeof(a->value) - len);
  453 + a->media_id = b->media->type_id;
  454 + a->broadcast = !memcmp(mac, b->bcast_addr.value, len);
  455 +}
  456 +
  457 +int tipc_enable_l2_media(struct tipc_bearer *b)
  458 +{
  459 + struct net_device *dev;
  460 + char *driver_name = strchr((const char *)b->name, ':') + 1;
  461 +
  462 + /* Find device with specified name */
  463 + dev = dev_get_by_name(&init_net, driver_name);
  464 + if (!dev)
  465 + return -ENODEV;
  466 +
  467 + /* Associate TIPC bearer with Ethernet bearer */
  468 + b->media_ptr = dev;
  469 + memset(b->bcast_addr.value, 0, sizeof(b->bcast_addr.value));
  470 + memcpy(b->bcast_addr.value, dev->broadcast, b->media->hwaddr_len);
  471 + b->bcast_addr.media_id = b->media->type_id;
  472 + b->bcast_addr.broadcast = 1;
  473 + b->mtu = dev->mtu;
  474 + tipc_l2_media_addr_set(b, &b->addr, (char *)dev->dev_addr);
  475 + rcu_assign_pointer(dev->tipc_ptr, b);
  476 + return 0;
  477 +}
  478 +
  479 +/* tipc_disable_l2_media - detach TIPC bearer from an Ethernet interface
  480 + *
  481 + * Mark Ethernet bearer as inactive so that incoming buffers are thrown away,
  482 + * then get worker thread to complete bearer cleanup. (Can't do cleanup
  483 + * here because cleanup code needs to sleep and caller holds spinlocks.)
  484 + */
  485 +void tipc_disable_l2_media(struct tipc_bearer *b)
  486 +{
  487 + struct net_device *dev = (struct net_device *)b->media_ptr;
  488 + RCU_INIT_POINTER(dev->tipc_ptr, NULL);
  489 + dev_put(dev);
  490 +}
  491 +
  492 +/**
  493 + * tipc_l2_send_msg - send a TIPC packet out over an Ethernet interface
  494 + * @buf: the packet to be sent
  495 + * @b_ptr: the bearer throught which the packet is to be sent
  496 + * @dest: peer destination address
  497 + */
  498 +int tipc_l2_send_msg(struct sk_buff *buf, struct tipc_bearer *b,
  499 + struct tipc_media_addr *dest)
  500 +{
  501 + struct sk_buff *clone;
  502 + int delta;
  503 + struct net_device *dev = (struct net_device *)b->media_ptr;
  504 +
  505 + clone = skb_clone(buf, GFP_ATOMIC);
  506 + if (!clone)
  507 + return 0;
  508 +
  509 + delta = dev->hard_header_len - skb_headroom(buf);
  510 + if ((delta > 0) &&
  511 + pskb_expand_head(clone, SKB_DATA_ALIGN(delta), 0, GFP_ATOMIC)) {
  512 + kfree_skb(clone);
  513 + return 0;
  514 + }
  515 +
  516 + skb_reset_network_header(clone);
  517 + clone->dev = dev;
  518 + clone->protocol = htons(ETH_P_TIPC);
  519 + dev_hard_header(clone, dev, ETH_P_TIPC, dest->value,
  520 + dev->dev_addr, clone->len);
  521 + dev_queue_xmit(clone);
  522 + return 0;
  523 +}
  524 +
  525 +/* tipc_bearer_send- sends buffer to destination over bearer
  526 + *
  527 + * IMPORTANT:
  528 + * The media send routine must not alter the buffer being passed in
  529 + * as it may be needed for later retransmission!
  530 + */
  531 +void tipc_bearer_send(struct tipc_bearer *b, struct sk_buff *buf,
  532 + struct tipc_media_addr *dest)
  533 +{
  534 + b->media->send_msg(buf, b, dest);
433 535 }
434 536  
435 537 /**
... ... @@ -84,6 +84,7 @@
84 84 * @tolerance: default time (in ms) before declaring link failure
85 85 * @window: default window (in packets) before declaring link congestion
86 86 * @type_id: TIPC media identifier
  87 + * @hwaddr_len: TIPC media address len
87 88 * @name: media name
88 89 */
89 90 struct tipc_media {
... ... @@ -100,6 +101,7 @@
100 101 u32 tolerance;
101 102 u32 window;
102 103 u32 type_id;
  104 + u32 hwaddr_len;
103 105 char name[TIPC_MAX_MEDIA_NAME];
104 106 };
105 107  
... ... @@ -128,8 +130,7 @@
128 130 * care of initializing all other fields.
129 131 */
130 132 struct tipc_bearer {
131   - struct net_device *dev;
132   - void *usr_handle; /* initalized by media */
  133 + void *media_ptr; /* initalized by media */
133 134 u32 mtu; /* initalized by media */
134 135 struct tipc_media_addr addr; /* initalized by media */
135 136 char name[TIPC_MAX_BEARER_NAME];
... ... @@ -178,6 +179,12 @@
178 179 int tipc_media_set_window(const char *name, u32 new_value);
179 180 void tipc_media_addr_printf(char *buf, int len, struct tipc_media_addr *a);
180 181 struct sk_buff *tipc_media_get_names(void);
  182 +void tipc_l2_media_addr_set(const struct tipc_bearer *b,
  183 + struct tipc_media_addr *a, char *mac);
  184 +int tipc_enable_l2_media(struct tipc_bearer *b);
  185 +void tipc_disable_l2_media(struct tipc_bearer *b);
  186 +int tipc_l2_send_msg(struct sk_buff *buf, struct tipc_bearer *b,
  187 + struct tipc_media_addr *dest);
181 188  
182 189 struct sk_buff *tipc_bearer_get_names(void);
183 190 void tipc_bearer_add_dest(struct tipc_bearer *b_ptr, u32 dest);
... ... @@ -188,19 +195,8 @@
188 195 int tipc_bearer_setup(void);
189 196 void tipc_bearer_cleanup(void);
190 197 void tipc_bearer_stop(void);
191   -
192   -/**
193   - * tipc_bearer_send- sends buffer to destination over bearer
194   - *
195   - * IMPORTANT:
196   - * The media send routine must not alter the buffer being passed in
197   - * as it may be needed for later retransmission!
198   - */
199   -static inline void tipc_bearer_send(struct tipc_bearer *b, struct sk_buff *buf,
200   - struct tipc_media_addr *dest)
201   -{
202   - b->media->send_msg(buf, b, dest);
203   -}
  198 +void tipc_bearer_send(struct tipc_bearer *b, struct sk_buff *buf,
  199 + struct tipc_media_addr *dest);
204 200  
205 201 #endif /* _TIPC_BEARER_H */
net/tipc/eth_media.c
Diff comments   View file @ e4d050c
... ... @@ -39,95 +39,10 @@
39 39  
40 40 #define ETH_ADDR_OFFSET 4 /* message header offset of MAC address */
41 41  
42   -/**
43   - * eth_media_addr_set - initialize Ethernet media address structure
44   - *
45   - * Media-dependent "value" field stores MAC address in first 6 bytes
46   - * and zeroes out the remaining bytes.
47   - */
48   -static void eth_media_addr_set(const struct tipc_bearer *tb_ptr,
49   - struct tipc_media_addr *a, char *mac)
  42 +/* convert Ethernet address to string */
  43 +static int tipc_eth_addr2str(struct tipc_media_addr *a, char *str_buf,
  44 + int str_size)
50 45 {
51   - memcpy(a->value, mac, ETH_ALEN);
52   - memset(a->value + ETH_ALEN, 0, sizeof(a->value) - ETH_ALEN);
53   - a->media_id = TIPC_MEDIA_TYPE_ETH;
54   - a->broadcast = !memcmp(mac, tb_ptr->bcast_addr.value, ETH_ALEN);
55   -}
56   -
57   -/**
58   - * send_msg - send a TIPC message out over an Ethernet interface
59   - */
60   -static int send_msg(struct sk_buff *buf, struct tipc_bearer *tb_ptr,
61   - struct tipc_media_addr *dest)
62   -{
63   - struct sk_buff *clone;
64   - int delta;
65   - struct net_device *dev = tb_ptr->dev;
66   -
67   - clone = skb_clone(buf, GFP_ATOMIC);
68   - if (!clone)
69   - return 0;
70   -
71   - delta = dev->hard_header_len - skb_headroom(buf);
72   - if ((delta > 0) &&
73   - pskb_expand_head(clone, SKB_DATA_ALIGN(delta), 0, GFP_ATOMIC)) {
74   - kfree_skb(clone);
75   - return 0;
76   - }
77   -
78   - skb_reset_network_header(clone);
79   - clone->dev = dev;
80   - clone->protocol = htons(ETH_P_TIPC);
81   - dev_hard_header(clone, dev, ETH_P_TIPC, dest->value,
82   - dev->dev_addr, clone->len);
83   - dev_queue_xmit(clone);
84   - return 0;
85   -}
86   -
87   -/**
88   - * enable_media - attach TIPC bearer to an Ethernet interface
89   - */
90   -static int enable_media(struct tipc_bearer *tb_ptr)
91   -{
92   - struct net_device *dev;
93   - char *driver_name = strchr((const char *)tb_ptr->name, ':') + 1;
94   -
95   - /* Find device with specified name */
96   - dev = dev_get_by_name(&init_net, driver_name);
97   - if (!dev)
98   - return -ENODEV;
99   -
100   - /* Associate TIPC bearer with Ethernet bearer */
101   - tb_ptr->dev = dev;
102   - tb_ptr->usr_handle = NULL;
103   - memset(tb_ptr->bcast_addr.value, 0, sizeof(tb_ptr->bcast_addr.value));
104   - memcpy(tb_ptr->bcast_addr.value, dev->broadcast, ETH_ALEN);
105   - tb_ptr->bcast_addr.media_id = TIPC_MEDIA_TYPE_ETH;
106   - tb_ptr->bcast_addr.broadcast = 1;
107   - tb_ptr->mtu = dev->mtu;
108   - eth_media_addr_set(tb_ptr, &tb_ptr->addr, (char *)dev->dev_addr);
109   - rcu_assign_pointer(dev->tipc_ptr, tb_ptr);
110   - return 0;
111   -}
112   -
113   -/**
114   - * disable_media - detach TIPC bearer from an Ethernet interface
115   - *
116   - * Mark Ethernet bearer as inactive so that incoming buffers are thrown away,
117   - * then get worker thread to complete bearer cleanup. (Can't do cleanup
118   - * here because cleanup code needs to sleep and caller holds spinlocks.)
119   - */
120   -static void disable_media(struct tipc_bearer *tb_ptr)
121   -{
122   - RCU_INIT_POINTER(tb_ptr->dev->tipc_ptr, NULL);
123   - dev_put(tb_ptr->dev);
124   -}
125   -
126   -/**
127   - * eth_addr2str - convert Ethernet address to string
128   - */
129   -static int eth_addr2str(struct tipc_media_addr *a, char *str_buf, int str_size)
130   -{
131 46 if (str_size < 18) /* 18 = strlen("aa:bb:cc:dd:ee:ff\0") */
132 47 return 1;
133 48  
... ... @@ -135,10 +50,8 @@
135 50 return 0;
136 51 }
137 52  
138   -/**
139   - * eth_str2addr - convert Ethernet address format to message header format
140   - */
141   -static int eth_addr2msg(struct tipc_media_addr *a, char *msg_area)
  53 +/* convert Ethernet address format to message header format */
  54 +static int tipc_eth_addr2msg(struct tipc_media_addr *a, char *msg_area)
142 55 {
143 56 memset(msg_area, 0, TIPC_MEDIA_ADDR_SIZE);
144 57 msg_area[TIPC_MEDIA_TYPE_OFFSET] = TIPC_MEDIA_TYPE_ETH;
145 58  
146 59  
147 60  
148 61  
... ... @@ -146,33 +59,30 @@
146 59 return 0;
147 60 }
148 61  
149   -/**
150   - * eth_str2addr - convert message header address format to Ethernet format
151   - */
152   -static int eth_msg2addr(const struct tipc_bearer *tb_ptr,
153   - struct tipc_media_addr *a, char *msg_area)
  62 +/* convert message header address format to Ethernet format */
  63 +static int tipc_eth_msg2addr(const struct tipc_bearer *tb_ptr,
  64 + struct tipc_media_addr *a, char *msg_area)
154 65 {
155 66 if (msg_area[TIPC_MEDIA_TYPE_OFFSET] != TIPC_MEDIA_TYPE_ETH)
156 67 return 1;
157 68  
158   - eth_media_addr_set(tb_ptr, a, msg_area + ETH_ADDR_OFFSET);
  69 + tipc_l2_media_addr_set(tb_ptr, a, msg_area + ETH_ADDR_OFFSET);
159 70 return 0;
160 71 }
161 72  
162   -/*
163   - * Ethernet media registration info
164   - */
  73 +/* Ethernet media registration info */
165 74 struct tipc_media eth_media_info = {
166   - .send_msg = send_msg,
167   - .enable_media = enable_media,
168   - .disable_media = disable_media,
169   - .addr2str = eth_addr2str,
170   - .addr2msg = eth_addr2msg,
171   - .msg2addr = eth_msg2addr,
  75 + .send_msg = tipc_l2_send_msg,
  76 + .enable_media = tipc_enable_l2_media,
  77 + .disable_media = tipc_disable_l2_media,
  78 + .addr2str = tipc_eth_addr2str,
  79 + .addr2msg = tipc_eth_addr2msg,
  80 + .msg2addr = tipc_eth_msg2addr,
172 81 .priority = TIPC_DEF_LINK_PRI,
173 82 .tolerance = TIPC_DEF_LINK_TOL,
174 83 .window = TIPC_DEF_LINK_WIN,
175 84 .type_id = TIPC_MEDIA_TYPE_ETH,
  85 + .hwaddr_len = ETH_ALEN,
176 86 .name = "eth"
177 87 };
... ... @@ -42,95 +42,10 @@
42 42 #include "core.h"
43 43 #include "bearer.h"
44 44  
45   -/**
46   - * ib_media_addr_set - initialize Infiniband media address structure
47   - *
48   - * Media-dependent "value" field stores MAC address in first 6 bytes
49   - * and zeroes out the remaining bytes.
50   - */
51   -static void ib_media_addr_set(const struct tipc_bearer *tb_ptr,
52   - struct tipc_media_addr *a, char *mac)
  45 +/* convert InfiniBand address to string */
  46 +static int tipc_ib_addr2str(struct tipc_media_addr *a, char *str_buf,
  47 + int str_size)
53 48 {
54   - BUILD_BUG_ON(sizeof(a->value) < INFINIBAND_ALEN);
55   - memcpy(a->value, mac, INFINIBAND_ALEN);
56   - a->media_id = TIPC_MEDIA_TYPE_IB;
57   - a->broadcast = !memcmp(mac, tb_ptr->bcast_addr.value, INFINIBAND_ALEN);
58   -}
59   -
60   -/**
61   - * send_msg - send a TIPC message out over an InfiniBand interface
62   - */
63   -static int send_msg(struct sk_buff *buf, struct tipc_bearer *tb_ptr,
64   - struct tipc_media_addr *dest)
65   -{
66   - struct sk_buff *clone;
67   - int delta;
68   - struct net_device *dev = tb_ptr->dev;
69   -
70   - clone = skb_clone(buf, GFP_ATOMIC);
71   - if (!clone)
72   - return 0;
73   -
74   - delta = dev->hard_header_len - skb_headroom(buf);
75   - if ((delta > 0) &&
76   - pskb_expand_head(clone, SKB_DATA_ALIGN(delta), 0, GFP_ATOMIC)) {
77   - kfree_skb(clone);
78   - return 0;
79   - }
80   -
81   - skb_reset_network_header(clone);
82   - clone->dev = dev;
83   - clone->protocol = htons(ETH_P_TIPC);
84   - dev_hard_header(clone, dev, ETH_P_TIPC, dest->value,
85   - dev->dev_addr, clone->len);
86   - dev_queue_xmit(clone);
87   - return 0;
88   -}
89   -
90   -/**
91   - * enable_media - attach TIPC bearer to an InfiniBand interface
92   - */
93   -static int enable_media(struct tipc_bearer *tb_ptr)
94   -{
95   - struct net_device *dev;
96   - char *driver_name = strchr((const char *)tb_ptr->name, ':') + 1;
97   -
98   - /* Find device with specified name */
99   - dev = dev_get_by_name(&init_net, driver_name);
100   - if (!dev)
101   - return -ENODEV;
102   -
103   - /* Associate TIPC bearer with InfiniBand bearer */
104   - tb_ptr->dev = dev;
105   - tb_ptr->usr_handle = NULL;
106   - memset(tb_ptr->bcast_addr.value, 0, sizeof(tb_ptr->bcast_addr.value));
107   - memcpy(tb_ptr->bcast_addr.value, dev->broadcast, INFINIBAND_ALEN);
108   - tb_ptr->bcast_addr.media_id = TIPC_MEDIA_TYPE_IB;
109   - tb_ptr->bcast_addr.broadcast = 1;
110   - tb_ptr->mtu = dev->mtu;
111   - ib_media_addr_set(tb_ptr, &tb_ptr->addr, (char *)dev->dev_addr);
112   - rcu_assign_pointer(dev->tipc_ptr, tb_ptr);
113   - return 0;
114   -}
115   -
116   -/**
117   - * disable_media - detach TIPC bearer from an InfiniBand interface
118   - *
119   - * Mark InfiniBand bearer as inactive so that incoming buffers are thrown away,
120   - * then get worker thread to complete bearer cleanup. (Can't do cleanup
121   - * here because cleanup code needs to sleep and caller holds spinlocks.)
122   - */
123   -static void disable_media(struct tipc_bearer *tb_ptr)
124   -{
125   - RCU_INIT_POINTER(tb_ptr->dev->tipc_ptr, NULL);
126   - dev_put(tb_ptr->dev);
127   -}
128   -
129   -/**
130   - * ib_addr2str - convert InfiniBand address to string
131   - */
132   -static int ib_addr2str(struct tipc_media_addr *a, char *str_buf, int str_size)
133   -{
134 49 if (str_size < 60) /* 60 = 19 * strlen("xx:") + strlen("xx\0") */
135 50 return 1;
136 51  
... ... @@ -139,10 +54,8 @@
139 54 return 0;
140 55 }
141 56  
142   -/**
143   - * ib_addr2msg - convert InfiniBand address format to message header format
144   - */
145   -static int ib_addr2msg(struct tipc_media_addr *a, char *msg_area)
  57 +/* convert InfiniBand address format to message header format */
  58 +static int tipc_ib_addr2msg(struct tipc_media_addr *a, char *msg_area)
146 59 {
147 60 memset(msg_area, 0, TIPC_MEDIA_ADDR_SIZE);
148 61 msg_area[TIPC_MEDIA_TYPE_OFFSET] = TIPC_MEDIA_TYPE_IB;
149 62  
150 63  
151 64  
152 65  
... ... @@ -150,30 +63,27 @@
150 63 return 0;
151 64 }
152 65  
153   -/**
154   - * ib_msg2addr - convert message header address format to InfiniBand format
155   - */
156   -static int ib_msg2addr(const struct tipc_bearer *tb_ptr,
157   - struct tipc_media_addr *a, char *msg_area)
  66 +/* convert message header address format to InfiniBand format */
  67 +static int tipc_ib_msg2addr(const struct tipc_bearer *tb_ptr,
  68 + struct tipc_media_addr *a, char *msg_area)
158 69 {
159   - ib_media_addr_set(tb_ptr, a, msg_area);
  70 + tipc_l2_media_addr_set(tb_ptr, a, msg_area);
160 71 return 0;
161 72 }
162 73  
163   -/*
164   - * InfiniBand media registration info
165   - */
  74 +/* InfiniBand media registration info */
166 75 struct tipc_media ib_media_info = {
167   - .send_msg = send_msg,
168   - .enable_media = enable_media,
169   - .disable_media = disable_media,
170   - .addr2str = ib_addr2str,
171   - .addr2msg = ib_addr2msg,
172   - .msg2addr = ib_msg2addr,
  76 + .send_msg = tipc_l2_send_msg,
  77 + .enable_media = tipc_enable_l2_media,
  78 + .disable_media = tipc_disable_l2_media,
  79 + .addr2str = tipc_ib_addr2str,
  80 + .addr2msg = tipc_ib_addr2msg,
  81 + .msg2addr = tipc_ib_msg2addr,
173 82 .priority = TIPC_DEF_LINK_PRI,
174 83 .tolerance = TIPC_DEF_LINK_TOL,
175 84 .window = TIPC_DEF_LINK_WIN,
176 85 .type_id = TIPC_MEDIA_TYPE_IB,
  86 + .hwaddr_len = INFINIBAND_ALEN,
177 87 .name = "ib"
178 88 };