2 * The Guest network driver.
4 * This is very simple a virtual network driver, and our last Guest driver.
5 * The only trick is that it can talk directly to multiple other recipients
6 * (ie. other Guests on the same network). It can also be used with only the
10 /* Copyright 2006 Rusty Russell <rusty@rustcorp.com.au> IBM Corporation
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 #include <linux/netdevice.h>
28 #include <linux/etherdevice.h>
29 #include <linux/module.h>
30 #include <linux/mm_types.h>
32 #include <linux/lguest_bus.h>
34 #define SHARED_SIZE PAGE_SIZE
38 /*D:530 The "struct lguestnet_info" contains all the information we need to
39 * know about the network device. */
42 /* The mapped device page(s) (an array of "struct lguest_net"). */
43 struct lguest_net
*peer
;
44 /* The physical address of the device page(s) */
45 unsigned long peer_phys
;
46 /* The size of the device page(s). */
47 unsigned long mapsize
;
49 /* The lguest_device I come from */
50 struct lguest_device
*lgdev
;
52 /* My peerid (ie. my slot in the array). */
55 /* Receive queue: the network packets waiting to be filled. */
56 struct sk_buff
*skb
[NUM_SKBS
];
57 struct lguest_dma dma
[NUM_SKBS
];
61 /* How many bytes left in this page. */
62 static unsigned int rest_of_page(void *data
)
64 return PAGE_SIZE
- ((unsigned long)data
% PAGE_SIZE
);
67 /*D:570 Each peer (ie. Guest or Host) on the network binds their receive
68 * buffers to a different key: we simply use the physical address of the
69 * device's memory page plus the peer number. The Host insists that all keys
70 * be a multiple of 4, so we multiply the peer number by 4. */
71 static unsigned long peer_key(struct lguestnet_info
*info
, unsigned peernum
)
73 return info
->peer_phys
+ 4 * peernum
;
76 /* This is the routine which sets up a "struct lguest_dma" to point to a
77 * network packet, similar to req_to_dma() in lguest_blk.c. The structure of a
78 * "struct sk_buff" has grown complex over the years: it consists of a "head"
79 * linear section pointed to by "skb->data", and possibly an array of
80 * "fragments" in the case of a non-linear packet.
82 * Our receive buffers don't use fragments at all but outgoing skbs might, so
84 static void skb_to_dma(const struct sk_buff
*skb
, unsigned int headlen
,
85 struct lguest_dma
*dma
)
89 /* First, we put the linear region into the "struct lguest_dma". Each
90 * entry can't go over a page boundary, so even though all our packets
91 * are 1514 bytes or less, we might need to use two entries here: */
92 for (i
= seg
= 0; i
< headlen
; seg
++, i
+= rest_of_page(skb
->data
+i
)) {
93 dma
->addr
[seg
] = virt_to_phys(skb
->data
+ i
);
94 dma
->len
[seg
] = min((unsigned)(headlen
- i
),
95 rest_of_page(skb
->data
+ i
));
98 /* Now we handle the fragments: at least they're guaranteed not to go
99 * over a page. skb_shinfo(skb) returns a pointer to the structure
100 * which tells us about the number of fragments and the fragment
102 for (i
= 0; i
< skb_shinfo(skb
)->nr_frags
; i
++, seg
++) {
103 const skb_frag_t
*f
= &skb_shinfo(skb
)->frags
[i
];
104 /* Should not happen with MTU less than 64k - 2 * PAGE_SIZE. */
105 if (seg
== LGUEST_MAX_DMA_SECTIONS
) {
106 /* We will end up sending a truncated packet should
107 * this ever happen. Plus, a cool log message! */
108 printk("Woah dude! Megapacket!\n");
111 dma
->addr
[seg
] = page_to_phys(f
->page
) + f
->page_offset
;
112 dma
->len
[seg
] = f
->size
;
115 /* If after all that we didn't use the entire "struct lguest_dma"
116 * array, we terminate it with a 0 length. */
117 if (seg
< LGUEST_MAX_DMA_SECTIONS
)
122 * Packet transmission.
124 * Our packet transmission is a little unusual. A real network card would just
125 * send out the packet and leave the receivers to decide if they're interested.
126 * Instead, we look through the network device memory page and see if any of
127 * the ethernet addresses match the packet destination, and if so we send it to
130 * This is made a little more complicated in two cases. The first case is
131 * broadcast packets: for that we send the packet to all Guests on the network,
132 * one at a time. The second case is "promiscuous" mode, where a Guest wants
133 * to see all the packets on the network. We need a way for the Guest to tell
134 * us it wants to see all packets, so it sets the "multicast" bit on its
135 * published MAC address, which is never valid in a real ethernet address.
137 #define PROMISC_BIT 0x01
139 /* This is the callback which is summoned whenever the network device's
140 * multicast or promiscuous state changes. If the card is in promiscuous mode,
141 * we advertise that in our ethernet address in the device's memory. We do the
142 * same if Linux wants any or all multicast traffic. */
143 static void lguestnet_set_multicast(struct net_device
*dev
)
145 struct lguestnet_info
*info
= netdev_priv(dev
);
147 if ((dev
->flags
& (IFF_PROMISC
|IFF_ALLMULTI
)) || dev
->mc_count
)
148 info
->peer
[info
->me
].mac
[0] |= PROMISC_BIT
;
150 info
->peer
[info
->me
].mac
[0] &= ~PROMISC_BIT
;
153 /* A simple test function to see if a peer wants to see all packets.*/
154 static int promisc(struct lguestnet_info
*info
, unsigned int peer
)
156 return info
->peer
[peer
].mac
[0] & PROMISC_BIT
;
159 /* Another simple function to see if a peer's advertised ethernet address
160 * matches a packet's destination ethernet address. */
161 static int mac_eq(const unsigned char mac
[ETH_ALEN
],
162 struct lguestnet_info
*info
, unsigned int peer
)
164 /* Ignore multicast bit, which peer turns on to mean promisc. */
165 if ((info
->peer
[peer
].mac
[0] & (~PROMISC_BIT
)) != mac
[0])
167 return memcmp(mac
+1, info
->peer
[peer
].mac
+1, ETH_ALEN
-1) == 0;
170 /* This is the function which actually sends a packet once we've decided a
172 static void transfer_packet(struct net_device
*dev
,
174 unsigned int peernum
)
176 struct lguestnet_info
*info
= netdev_priv(dev
);
177 struct lguest_dma dma
;
179 /* We use our handy "struct lguest_dma" packing function to prepare
180 * the skb for sending. */
181 skb_to_dma(skb
, skb_headlen(skb
), &dma
);
182 pr_debug("xfer length %04x (%u)\n", htons(skb
->len
), skb
->len
);
184 /* This is the actual send call which copies the packet. */
185 lguest_send_dma(peer_key(info
, peernum
), &dma
);
187 /* Check that the entire packet was transmitted. If not, it could mean
188 * that the other Guest registered a short receive buffer, but this
189 * driver should never do that. More likely, the peer is dead. */
190 if (dma
.used_len
!= skb
->len
) {
191 dev
->stats
.tx_carrier_errors
++;
192 pr_debug("Bad xfer to peer %i: %i of %i (dma %p/%i)\n",
193 peernum
, dma
.used_len
, skb
->len
,
194 (void *)dma
.addr
[0], dma
.len
[0]);
196 /* On success we update the stats. */
197 dev
->stats
.tx_bytes
+= skb
->len
;
198 dev
->stats
.tx_packets
++;
202 /* Another helper function to tell is if a slot in the device memory is unused.
203 * Since we always set the Local Assignment bit in the ethernet address, the
204 * first byte can never be 0. */
205 static int unused_peer(const struct lguest_net peer
[], unsigned int num
)
207 return peer
[num
].mac
[0] == 0;
210 /* Finally, here is the routine which handles an outgoing packet. It's called
211 * "start_xmit" for traditional reasons. */
212 static int lguestnet_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
216 struct lguestnet_info
*info
= netdev_priv(dev
);
217 /* Extract the destination ethernet address from the packet. */
218 const unsigned char *dest
= ((struct ethhdr
*)skb
->data
)->h_dest
;
220 pr_debug("%s: xmit %02x:%02x:%02x:%02x:%02x:%02x\n",
221 dev
->name
, dest
[0],dest
[1],dest
[2],dest
[3],dest
[4],dest
[5]);
223 /* If it's a multicast packet, we broadcast to everyone. That's not
224 * very efficient, but there are very few applications which actually
225 * use multicast, which is a shame really.
227 * As etherdevice.h points out: "By definition the broadcast address is
228 * also a multicast address." So we don't have to test for broadcast
229 * packets separately. */
230 broadcast
= is_multicast_ether_addr(dest
);
232 /* Look through all the published ethernet addresses to see if we
233 * should send this packet. */
234 for (i
= 0; i
< info
->mapsize
/sizeof(struct lguest_net
); i
++) {
235 /* We don't send to ourselves (we actually can't SEND_DMA to
236 * ourselves anyway), and don't send to unused slots.*/
237 if (i
== info
->me
|| unused_peer(info
->peer
, i
))
240 /* If it's broadcast we send it. If they want every packet we
241 * send it. If the destination matches their address we send
242 * it. Otherwise we go to the next peer. */
243 if (!broadcast
&& !promisc(info
, i
) && !mac_eq(dest
, info
, i
))
246 pr_debug("lguestnet %s: sending from %i to %i\n",
247 dev
->name
, info
->me
, i
);
248 /* Our routine which actually does the transfer. */
249 transfer_packet(dev
, skb
, i
);
252 /* An xmit routine is expected to dispose of the packet, so we do. */
255 /* As per kernel convention, 0 means success. This is why I love
256 * networking: even if we never sent to anyone, that's still
264 * First, here's a helper routine which fills one of our array of receive
266 static int fill_slot(struct net_device
*dev
, unsigned int slot
)
268 struct lguestnet_info
*info
= netdev_priv(dev
);
270 /* We can receive ETH_DATA_LEN (1500) byte packets, plus a standard
271 * ethernet header of ETH_HLEN (14) bytes. */
272 info
->skb
[slot
] = netdev_alloc_skb(dev
, ETH_HLEN
+ ETH_DATA_LEN
);
273 if (!info
->skb
[slot
]) {
274 printk("%s: could not fill slot %i\n", dev
->name
, slot
);
278 /* skb_to_dma() is a helper which sets up the "struct lguest_dma" to
279 * point to the data in the skb: we also use it for sending out a
281 skb_to_dma(info
->skb
[slot
], ETH_HLEN
+ ETH_DATA_LEN
, &info
->dma
[slot
]);
283 /* This is a Write Memory Barrier: it ensures that the entry in the
284 * receive buffer array is written *before* we set the "used_len" entry
285 * to 0. If the Host were looking at the receive buffer array from a
286 * different CPU, it could potentially see "used_len = 0" and not see
287 * the updated receive buffer information. This would be a horribly
288 * nasty bug, so make sure the compiler and CPU know this has to happen
291 /* Writing 0 to "used_len" tells the Host it can use this receive
293 info
->dma
[slot
].used_len
= 0;
297 /* This is the actual receive routine. When we receive an interrupt from the
298 * Host to tell us a packet has been delivered, we arrive here: */
299 static irqreturn_t
lguestnet_rcv(int irq
, void *dev_id
)
301 struct net_device
*dev
= dev_id
;
302 struct lguestnet_info
*info
= netdev_priv(dev
);
303 unsigned int i
, done
= 0;
305 /* Look through our entire receive array for an entry which has data
307 for (i
= 0; i
< ARRAY_SIZE(info
->dma
); i
++) {
311 length
= info
->dma
[i
].used_len
;
315 /* We've found one! Remember the skb (we grabbed the length
316 * above), and immediately refill the slot we've taken it
322 /* This shouldn't happen: micropackets could be sent by a
323 * badly-behaved Guest on the network, but the Host will never
324 * stuff more data in the buffer than the buffer length. */
325 if (length
< ETH_HLEN
|| length
> ETH_HLEN
+ ETH_DATA_LEN
) {
326 pr_debug(KERN_WARNING
"%s: unbelievable skb len: %i\n",
332 /* skb_put(), what a great function! I've ranted about this
333 * function before (http://lkml.org/lkml/1999/9/26/24). You
334 * call it after you've added data to the end of an skb (in
335 * this case, it was the Host which wrote the data). */
336 skb_put(skb
, length
);
338 /* The ethernet header contains a protocol field: we use the
339 * standard helper to extract it, and place the result in
340 * skb->protocol. The helper also sets up skb->pkt_type and
341 * eats up the ethernet header from the front of the packet. */
342 skb
->protocol
= eth_type_trans(skb
, dev
);
344 /* If this device doesn't need checksums for sending, we also
345 * don't need to check the packets when they come in. */
346 if (dev
->features
& NETIF_F_NO_CSUM
)
347 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
349 /* As a last resort for debugging the driver or the lguest I/O
350 * subsystem, you can uncomment the "#define DEBUG" at the top
351 * of this file, which turns all the pr_debug() into printk()
352 * and floods the logs. */
353 pr_debug("Receiving skb proto 0x%04x len %i type %i\n",
354 ntohs(skb
->protocol
), skb
->len
, skb
->pkt_type
);
356 /* Update the packet and byte counts (visible from ifconfig,
357 * and good for debugging). */
358 dev
->stats
.rx_bytes
+= skb
->len
;
359 dev
->stats
.rx_packets
++;
361 /* Hand our fresh network packet into the stack's "network
362 * interface receive" routine. That will free the packet
363 * itself when it's finished. */
367 /* If we found any packets, we assume the interrupt was for us. */
368 return done
? IRQ_HANDLED
: IRQ_NONE
;
371 /*D:550 This is where we start: when the device is brought up by dhcpd or
372 * ifconfig. At this point we advertise our MAC address to the rest of the
373 * network, and register receive buffers ready for incoming packets. */
374 static int lguestnet_open(struct net_device
*dev
)
377 struct lguestnet_info
*info
= netdev_priv(dev
);
379 /* Copy our MAC address into the device page, so others on the network
381 memcpy(info
->peer
[info
->me
].mac
, dev
->dev_addr
, ETH_ALEN
);
383 /* We might already be in promisc mode (dev->flags & IFF_PROMISC). Our
384 * set_multicast callback handles this already, so we call it now. */
385 lguestnet_set_multicast(dev
);
387 /* Allocate packets and put them into our "struct lguest_dma" array.
388 * If we fail to allocate all the packets we could still limp along,
389 * but it's a sign of real stress so we should probably give up now. */
390 for (i
= 0; i
< ARRAY_SIZE(info
->dma
); i
++) {
391 if (fill_slot(dev
, i
) != 0)
395 /* Finally we tell the Host where our array of "struct lguest_dma"
396 * receive buffers is, binding it to the key corresponding to the
397 * device's physical memory plus our peerid. */
398 if (lguest_bind_dma(peer_key(info
,info
->me
), info
->dma
,
399 NUM_SKBS
, lgdev_irq(info
->lgdev
)) != 0)
405 dev_kfree_skb(info
->skb
[i
]);
410 /* The close routine is called when the device is no longer in use: we clean up
412 static int lguestnet_close(struct net_device
*dev
)
415 struct lguestnet_info
*info
= netdev_priv(dev
);
417 /* Clear all trace of our existence out of the device memory by setting
418 * the slot which held our MAC address to 0 (unused). */
419 memset(&info
->peer
[info
->me
], 0, sizeof(info
->peer
[info
->me
]));
421 /* Unregister our array of receive buffers */
422 lguest_unbind_dma(peer_key(info
, info
->me
), info
->dma
);
423 for (i
= 0; i
< ARRAY_SIZE(info
->dma
); i
++)
424 dev_kfree_skb(info
->skb
[i
]);
428 /*D:510 The network device probe function is basically a standard ethernet
429 * device setup. It reads the "struct lguest_device_desc" and sets the "struct
430 * net_device". Oh, the line-by-line excitement! Let's skip over it. :*/
431 static int lguestnet_probe(struct lguest_device
*lgdev
)
433 int err
, irqf
= IRQF_SHARED
;
434 struct net_device
*dev
;
435 struct lguestnet_info
*info
;
436 struct lguest_device_desc
*desc
= &lguest_devices
[lgdev
->index
];
438 pr_debug("lguest_net: probing for device %i\n", lgdev
->index
);
440 dev
= alloc_etherdev(sizeof(struct lguestnet_info
));
444 SET_MODULE_OWNER(dev
);
446 /* Ethernet defaults with some changes */
448 dev
->set_mac_address
= NULL
;
450 dev
->dev_addr
[0] = 0x02; /* set local assignment bit (IEEE802) */
451 dev
->dev_addr
[1] = 0x00;
452 memcpy(&dev
->dev_addr
[2], &lguest_data
.guestid
, 2);
453 dev
->dev_addr
[4] = 0x00;
454 dev
->dev_addr
[5] = 0x00;
456 dev
->open
= lguestnet_open
;
457 dev
->stop
= lguestnet_close
;
458 dev
->hard_start_xmit
= lguestnet_start_xmit
;
460 /* We don't actually support multicast yet, but turning on/off
461 * promisc also calls dev->set_multicast_list. */
462 dev
->set_multicast_list
= lguestnet_set_multicast
;
463 SET_NETDEV_DEV(dev
, &lgdev
->dev
);
465 /* The network code complains if you have "scatter-gather" capability
466 * if you don't also handle checksums (it seem that would be
467 * "illogical"). So we use a lie of omission and don't tell it that we
468 * can handle scattered packets unless we also don't want checksums,
469 * even though to us they're completely independent. */
470 if (desc
->features
& LGUEST_NET_F_NOCSUM
)
471 dev
->features
= NETIF_F_SG
|NETIF_F_NO_CSUM
;
473 info
= netdev_priv(dev
);
474 info
->mapsize
= PAGE_SIZE
* desc
->num_pages
;
475 info
->peer_phys
= ((unsigned long)desc
->pfn
<< PAGE_SHIFT
);
477 info
->peer
= lguest_map(info
->peer_phys
, desc
->num_pages
);
483 /* This stores our peerid (upper bits reserved for future). */
484 info
->me
= (desc
->features
& (info
->mapsize
-1));
486 err
= register_netdev(dev
);
488 pr_debug("lguestnet: registering device failed\n");
492 if (lguest_devices
[lgdev
->index
].features
& LGUEST_DEVICE_F_RANDOMNESS
)
493 irqf
|= IRQF_SAMPLE_RANDOM
;
494 if (request_irq(lgdev_irq(lgdev
), lguestnet_rcv
, irqf
, "lguestnet",
496 pr_debug("lguestnet: cannot get irq %i\n", lgdev_irq(lgdev
));
500 pr_debug("lguestnet: registered device %s\n", dev
->name
);
501 /* Finally, we put the "struct net_device" in the generic "struct
502 * lguest_device"s private pointer. Again, it's not necessary, but
503 * makes sure the cool kernel kids don't tease us. */
504 lgdev
->private = dev
;
508 unregister_netdev(dev
);
510 lguest_unmap(info
->peer
);
516 static struct lguest_driver lguestnet_drv
= {
518 .owner
= THIS_MODULE
,
519 .device_type
= LGUEST_DEVICE_T_NET
,
520 .probe
= lguestnet_probe
,
523 static __init
int lguestnet_init(void)
525 return register_lguest_driver(&lguestnet_drv
);
527 module_init(lguestnet_init
);
529 MODULE_DESCRIPTION("Lguest network driver");
530 MODULE_LICENSE("GPL");
533 * This is the last of the Drivers, and with this we have covered the many and
534 * wonderous and fine (and boring) details of the Guest.
536 * "make Launcher" beckons, where we answer questions like "Where do Guests
537 * come from?", and "What do you do when someone asks for optimization?"