]>
Commit | Line | Data |
---|---|---|
d503e2fa RR |
1 | /* A simple network driver for lguest. |
2 | * | |
3 | * Copyright 2006 Rusty Russell <rusty@rustcorp.com.au> IBM Corporation | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or modify | |
6 | * it under the terms of the GNU General Public License as published by | |
7 | * the Free Software Foundation; either version 2 of the License, or | |
8 | * (at your option) any later version. | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, | |
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | * GNU General Public License for more details. | |
14 | * | |
15 | * You should have received a copy of the GNU General Public License | |
16 | * along with this program; if not, write to the Free Software | |
17 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
18 | */ | |
19 | //#define DEBUG | |
20 | #include <linux/netdevice.h> | |
21 | #include <linux/etherdevice.h> | |
22 | #include <linux/module.h> | |
23 | #include <linux/mm_types.h> | |
24 | #include <linux/io.h> | |
25 | #include <linux/lguest_bus.h> | |
26 | ||
27 | #define SHARED_SIZE PAGE_SIZE | |
28 | #define MAX_LANS 4 | |
29 | #define NUM_SKBS 8 | |
30 | ||
31 | struct lguestnet_info | |
32 | { | |
33 | /* The shared page(s). */ | |
34 | struct lguest_net *peer; | |
35 | unsigned long peer_phys; | |
36 | unsigned long mapsize; | |
37 | ||
38 | /* The lguest_device I come from */ | |
39 | struct lguest_device *lgdev; | |
40 | ||
41 | /* My peerid. */ | |
42 | unsigned int me; | |
43 | ||
44 | /* Receive queue. */ | |
45 | struct sk_buff *skb[NUM_SKBS]; | |
46 | struct lguest_dma dma[NUM_SKBS]; | |
47 | }; | |
48 | ||
49 | /* How many bytes left in this page. */ | |
50 | static unsigned int rest_of_page(void *data) | |
51 | { | |
52 | return PAGE_SIZE - ((unsigned long)data % PAGE_SIZE); | |
53 | } | |
54 | ||
55 | /* Simple convention: offset 4 * peernum. */ | |
56 | static unsigned long peer_key(struct lguestnet_info *info, unsigned peernum) | |
57 | { | |
58 | return info->peer_phys + 4 * peernum; | |
59 | } | |
60 | ||
61 | static void skb_to_dma(const struct sk_buff *skb, unsigned int headlen, | |
62 | struct lguest_dma *dma) | |
63 | { | |
64 | unsigned int i, seg; | |
65 | ||
66 | for (i = seg = 0; i < headlen; seg++, i += rest_of_page(skb->data+i)) { | |
67 | dma->addr[seg] = virt_to_phys(skb->data + i); | |
68 | dma->len[seg] = min((unsigned)(headlen - i), | |
69 | rest_of_page(skb->data + i)); | |
70 | } | |
71 | for (i = 0; i < skb_shinfo(skb)->nr_frags; i++, seg++) { | |
72 | const skb_frag_t *f = &skb_shinfo(skb)->frags[i]; | |
73 | /* Should not happen with MTU less than 64k - 2 * PAGE_SIZE. */ | |
74 | if (seg == LGUEST_MAX_DMA_SECTIONS) { | |
75 | printk("Woah dude! Megapacket!\n"); | |
76 | break; | |
77 | } | |
78 | dma->addr[seg] = page_to_phys(f->page) + f->page_offset; | |
79 | dma->len[seg] = f->size; | |
80 | } | |
81 | if (seg < LGUEST_MAX_DMA_SECTIONS) | |
82 | dma->len[seg] = 0; | |
83 | } | |
84 | ||
85 | /* We overload multicast bit to show promiscuous mode. */ | |
86 | #define PROMISC_BIT 0x01 | |
87 | ||
88 | static void lguestnet_set_multicast(struct net_device *dev) | |
89 | { | |
90 | struct lguestnet_info *info = netdev_priv(dev); | |
91 | ||
92 | if ((dev->flags & (IFF_PROMISC|IFF_ALLMULTI)) || dev->mc_count) | |
93 | info->peer[info->me].mac[0] |= PROMISC_BIT; | |
94 | else | |
95 | info->peer[info->me].mac[0] &= ~PROMISC_BIT; | |
96 | } | |
97 | ||
98 | static int promisc(struct lguestnet_info *info, unsigned int peer) | |
99 | { | |
100 | return info->peer[peer].mac[0] & PROMISC_BIT; | |
101 | } | |
102 | ||
103 | static int mac_eq(const unsigned char mac[ETH_ALEN], | |
104 | struct lguestnet_info *info, unsigned int peer) | |
105 | { | |
106 | /* Ignore multicast bit, which peer turns on to mean promisc. */ | |
107 | if ((info->peer[peer].mac[0] & (~PROMISC_BIT)) != mac[0]) | |
108 | return 0; | |
109 | return memcmp(mac+1, info->peer[peer].mac+1, ETH_ALEN-1) == 0; | |
110 | } | |
111 | ||
112 | static void transfer_packet(struct net_device *dev, | |
113 | struct sk_buff *skb, | |
114 | unsigned int peernum) | |
115 | { | |
116 | struct lguestnet_info *info = netdev_priv(dev); | |
117 | struct lguest_dma dma; | |
118 | ||
119 | skb_to_dma(skb, skb_headlen(skb), &dma); | |
120 | pr_debug("xfer length %04x (%u)\n", htons(skb->len), skb->len); | |
121 | ||
122 | lguest_send_dma(peer_key(info, peernum), &dma); | |
123 | if (dma.used_len != skb->len) { | |
124 | dev->stats.tx_carrier_errors++; | |
125 | pr_debug("Bad xfer to peer %i: %i of %i (dma %p/%i)\n", | |
126 | peernum, dma.used_len, skb->len, | |
127 | (void *)dma.addr[0], dma.len[0]); | |
128 | } else { | |
129 | dev->stats.tx_bytes += skb->len; | |
130 | dev->stats.tx_packets++; | |
131 | } | |
132 | } | |
133 | ||
134 | static int unused_peer(const struct lguest_net peer[], unsigned int num) | |
135 | { | |
136 | return peer[num].mac[0] == 0; | |
137 | } | |
138 | ||
139 | static int lguestnet_start_xmit(struct sk_buff *skb, struct net_device *dev) | |
140 | { | |
141 | unsigned int i; | |
142 | int broadcast; | |
143 | struct lguestnet_info *info = netdev_priv(dev); | |
144 | const unsigned char *dest = ((struct ethhdr *)skb->data)->h_dest; | |
145 | ||
146 | pr_debug("%s: xmit %02x:%02x:%02x:%02x:%02x:%02x\n", | |
147 | dev->name, dest[0],dest[1],dest[2],dest[3],dest[4],dest[5]); | |
148 | ||
149 | broadcast = is_multicast_ether_addr(dest); | |
150 | for (i = 0; i < info->mapsize/sizeof(struct lguest_net); i++) { | |
151 | if (i == info->me || unused_peer(info->peer, i)) | |
152 | continue; | |
153 | ||
154 | if (!broadcast && !promisc(info, i) && !mac_eq(dest, info, i)) | |
155 | continue; | |
156 | ||
157 | pr_debug("lguestnet %s: sending from %i to %i\n", | |
158 | dev->name, info->me, i); | |
159 | transfer_packet(dev, skb, i); | |
160 | } | |
161 | dev_kfree_skb(skb); | |
162 | return 0; | |
163 | } | |
164 | ||
165 | /* Find a new skb to put in this slot in shared mem. */ | |
166 | static int fill_slot(struct net_device *dev, unsigned int slot) | |
167 | { | |
168 | struct lguestnet_info *info = netdev_priv(dev); | |
169 | /* Try to create and register a new one. */ | |
170 | info->skb[slot] = netdev_alloc_skb(dev, ETH_HLEN + ETH_DATA_LEN); | |
171 | if (!info->skb[slot]) { | |
172 | printk("%s: could not fill slot %i\n", dev->name, slot); | |
173 | return -ENOMEM; | |
174 | } | |
175 | ||
176 | skb_to_dma(info->skb[slot], ETH_HLEN + ETH_DATA_LEN, &info->dma[slot]); | |
177 | wmb(); | |
178 | /* Now we tell hypervisor it can use the slot. */ | |
179 | info->dma[slot].used_len = 0; | |
180 | return 0; | |
181 | } | |
182 | ||
183 | static irqreturn_t lguestnet_rcv(int irq, void *dev_id) | |
184 | { | |
185 | struct net_device *dev = dev_id; | |
186 | struct lguestnet_info *info = netdev_priv(dev); | |
187 | unsigned int i, done = 0; | |
188 | ||
189 | for (i = 0; i < ARRAY_SIZE(info->dma); i++) { | |
190 | unsigned int length; | |
191 | struct sk_buff *skb; | |
192 | ||
193 | length = info->dma[i].used_len; | |
194 | if (length == 0) | |
195 | continue; | |
196 | ||
197 | done++; | |
198 | skb = info->skb[i]; | |
199 | fill_slot(dev, i); | |
200 | ||
201 | if (length < ETH_HLEN || length > ETH_HLEN + ETH_DATA_LEN) { | |
202 | pr_debug(KERN_WARNING "%s: unbelievable skb len: %i\n", | |
203 | dev->name, length); | |
204 | dev_kfree_skb(skb); | |
205 | continue; | |
206 | } | |
207 | ||
208 | skb_put(skb, length); | |
209 | skb->protocol = eth_type_trans(skb, dev); | |
210 | /* This is a reliable transport. */ | |
211 | if (dev->features & NETIF_F_NO_CSUM) | |
212 | skb->ip_summed = CHECKSUM_UNNECESSARY; | |
213 | pr_debug("Receiving skb proto 0x%04x len %i type %i\n", | |
214 | ntohs(skb->protocol), skb->len, skb->pkt_type); | |
215 | ||
216 | dev->stats.rx_bytes += skb->len; | |
217 | dev->stats.rx_packets++; | |
218 | netif_rx(skb); | |
219 | } | |
220 | return done ? IRQ_HANDLED : IRQ_NONE; | |
221 | } | |
222 | ||
223 | static int lguestnet_open(struct net_device *dev) | |
224 | { | |
225 | int i; | |
226 | struct lguestnet_info *info = netdev_priv(dev); | |
227 | ||
228 | /* Set up our MAC address */ | |
229 | memcpy(info->peer[info->me].mac, dev->dev_addr, ETH_ALEN); | |
230 | ||
231 | /* Turn on promisc mode if needed */ | |
232 | lguestnet_set_multicast(dev); | |
233 | ||
234 | for (i = 0; i < ARRAY_SIZE(info->dma); i++) { | |
235 | if (fill_slot(dev, i) != 0) | |
236 | goto cleanup; | |
237 | } | |
238 | if (lguest_bind_dma(peer_key(info,info->me), info->dma, | |
239 | NUM_SKBS, lgdev_irq(info->lgdev)) != 0) | |
240 | goto cleanup; | |
241 | return 0; | |
242 | ||
243 | cleanup: | |
244 | while (--i >= 0) | |
245 | dev_kfree_skb(info->skb[i]); | |
246 | return -ENOMEM; | |
247 | } | |
248 | ||
249 | static int lguestnet_close(struct net_device *dev) | |
250 | { | |
251 | unsigned int i; | |
252 | struct lguestnet_info *info = netdev_priv(dev); | |
253 | ||
254 | /* Clear all trace: others might deliver packets, we'll ignore it. */ | |
255 | memset(&info->peer[info->me], 0, sizeof(info->peer[info->me])); | |
256 | ||
257 | /* Deregister sg lists. */ | |
258 | lguest_unbind_dma(peer_key(info, info->me), info->dma); | |
259 | for (i = 0; i < ARRAY_SIZE(info->dma); i++) | |
260 | dev_kfree_skb(info->skb[i]); | |
261 | return 0; | |
262 | } | |
263 | ||
264 | static int lguestnet_probe(struct lguest_device *lgdev) | |
265 | { | |
266 | int err, irqf = IRQF_SHARED; | |
267 | struct net_device *dev; | |
268 | struct lguestnet_info *info; | |
269 | struct lguest_device_desc *desc = &lguest_devices[lgdev->index]; | |
270 | ||
271 | pr_debug("lguest_net: probing for device %i\n", lgdev->index); | |
272 | ||
273 | dev = alloc_etherdev(sizeof(struct lguestnet_info)); | |
274 | if (!dev) | |
275 | return -ENOMEM; | |
276 | ||
277 | SET_MODULE_OWNER(dev); | |
278 | ||
279 | /* Ethernet defaults with some changes */ | |
280 | ether_setup(dev); | |
281 | dev->set_mac_address = NULL; | |
282 | ||
283 | dev->dev_addr[0] = 0x02; /* set local assignment bit (IEEE802) */ | |
284 | dev->dev_addr[1] = 0x00; | |
285 | memcpy(&dev->dev_addr[2], &lguest_data.guestid, 2); | |
286 | dev->dev_addr[4] = 0x00; | |
287 | dev->dev_addr[5] = 0x00; | |
288 | ||
289 | dev->open = lguestnet_open; | |
290 | dev->stop = lguestnet_close; | |
291 | dev->hard_start_xmit = lguestnet_start_xmit; | |
292 | ||
293 | /* Turning on/off promisc will call dev->set_multicast_list. | |
294 | * We don't actually support multicast yet */ | |
295 | dev->set_multicast_list = lguestnet_set_multicast; | |
296 | SET_NETDEV_DEV(dev, &lgdev->dev); | |
297 | if (desc->features & LGUEST_NET_F_NOCSUM) | |
298 | dev->features = NETIF_F_SG|NETIF_F_NO_CSUM; | |
299 | ||
300 | info = netdev_priv(dev); | |
301 | info->mapsize = PAGE_SIZE * desc->num_pages; | |
302 | info->peer_phys = ((unsigned long)desc->pfn << PAGE_SHIFT); | |
303 | info->lgdev = lgdev; | |
304 | info->peer = lguest_map(info->peer_phys, desc->num_pages); | |
305 | if (!info->peer) { | |
306 | err = -ENOMEM; | |
307 | goto free; | |
308 | } | |
309 | ||
310 | /* This stores our peerid (upper bits reserved for future). */ | |
311 | info->me = (desc->features & (info->mapsize-1)); | |
312 | ||
313 | err = register_netdev(dev); | |
314 | if (err) { | |
315 | pr_debug("lguestnet: registering device failed\n"); | |
316 | goto unmap; | |
317 | } | |
318 | ||
319 | if (lguest_devices[lgdev->index].features & LGUEST_DEVICE_F_RANDOMNESS) | |
320 | irqf |= IRQF_SAMPLE_RANDOM; | |
321 | if (request_irq(lgdev_irq(lgdev), lguestnet_rcv, irqf, "lguestnet", | |
322 | dev) != 0) { | |
323 | pr_debug("lguestnet: cannot get irq %i\n", lgdev_irq(lgdev)); | |
324 | goto unregister; | |
325 | } | |
326 | ||
327 | pr_debug("lguestnet: registered device %s\n", dev->name); | |
328 | lgdev->private = dev; | |
329 | return 0; | |
330 | ||
331 | unregister: | |
332 | unregister_netdev(dev); | |
333 | unmap: | |
334 | lguest_unmap(info->peer); | |
335 | free: | |
336 | free_netdev(dev); | |
337 | return err; | |
338 | } | |
339 | ||
340 | static struct lguest_driver lguestnet_drv = { | |
341 | .name = "lguestnet", | |
342 | .owner = THIS_MODULE, | |
343 | .device_type = LGUEST_DEVICE_T_NET, | |
344 | .probe = lguestnet_probe, | |
345 | }; | |
346 | ||
347 | static __init int lguestnet_init(void) | |
348 | { | |
349 | return register_lguest_driver(&lguestnet_drv); | |
350 | } | |
351 | module_init(lguestnet_init); | |
352 | ||
353 | MODULE_DESCRIPTION("Lguest network driver"); | |
354 | MODULE_LICENSE("GPL"); |