cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

xpnet.c (17796B)


      1/*
      2 * This file is subject to the terms and conditions of the GNU General Public
      3 * License.  See the file "COPYING" in the main directory of this archive
      4 * for more details.
      5 *
      6 * (C) Copyright 2020 Hewlett Packard Enterprise Development LP
      7 * Copyright (C) 1999-2009 Silicon Graphics, Inc. All rights reserved.
      8 */
      9
     10/*
     11 * Cross Partition Network Interface (XPNET) support
     12 *
     13 *	XPNET provides a virtual network layered on top of the Cross
     14 *	Partition communication layer.
     15 *
     16 *	XPNET provides direct point-to-point and broadcast-like support
     17 *	for an ethernet-like device.  The ethernet broadcast medium is
     18 *	replaced with a point-to-point message structure which passes
     19 *	pointers to a DMA-capable block that a remote partition should
     20 *	retrieve and pass to the upper level networking layer.
     21 *
     22 */
     23
     24#include <linux/slab.h>
     25#include <linux/module.h>
     26#include <linux/netdevice.h>
     27#include <linux/etherdevice.h>
     28#include "xp.h"
     29
     30/*
     31 * The message payload transferred by XPC.
     32 *
     33 * buf_pa is the physical address where the DMA should pull from.
     34 *
     35 * NOTE: for performance reasons, buf_pa should _ALWAYS_ begin on a
     36 * cacheline boundary.  To accomplish this, we record the number of
     37 * bytes from the beginning of the first cacheline to the first useful
     38 * byte of the skb (leadin_ignore) and the number of bytes from the
     39 * last useful byte of the skb to the end of the last cacheline
     40 * (tailout_ignore).
     41 *
     42 * size is the number of bytes to transfer which includes the skb->len
     43 * (useful bytes of the senders skb) plus the leadin and tailout
     44 */
     45struct xpnet_message {
     46	u16 version;		/* Version for this message */
     47	u16 embedded_bytes;	/* #of bytes embedded in XPC message */
     48	u32 magic;		/* Special number indicating this is xpnet */
     49	unsigned long buf_pa;	/* phys address of buffer to retrieve */
     50	u32 size;		/* #of bytes in buffer */
     51	u8 leadin_ignore;	/* #of bytes to ignore at the beginning */
     52	u8 tailout_ignore;	/* #of bytes to ignore at the end */
     53	unsigned char data;	/* body of small packets */
     54};
     55
     56/*
     57 * Determine the size of our message, the cacheline aligned size,
     58 * and then the number of message will request from XPC.
     59 *
     60 * XPC expects each message to exist in an individual cacheline.
     61 */
     62#define XPNET_MSG_SIZE		XPC_MSG_PAYLOAD_MAX_SIZE
     63#define XPNET_MSG_DATA_MAX	\
     64		(XPNET_MSG_SIZE - offsetof(struct xpnet_message, data))
     65#define XPNET_MSG_NENTRIES	(PAGE_SIZE / XPC_MSG_MAX_SIZE)
     66
     67#define XPNET_MAX_KTHREADS	(XPNET_MSG_NENTRIES + 1)
     68#define XPNET_MAX_IDLE_KTHREADS	(XPNET_MSG_NENTRIES + 1)
     69
     70/*
     71 * Version number of XPNET implementation. XPNET can always talk to versions
     72 * with same major #, and never talk to versions with a different version.
     73 */
     74#define _XPNET_VERSION(_major, _minor)	(((_major) << 4) | (_minor))
     75#define XPNET_VERSION_MAJOR(_v)		((_v) >> 4)
     76#define XPNET_VERSION_MINOR(_v)		((_v) & 0xf)
     77
     78#define	XPNET_VERSION _XPNET_VERSION(1, 0)	/* version 1.0 */
     79#define	XPNET_VERSION_EMBED _XPNET_VERSION(1, 1)	/* version 1.1 */
     80#define XPNET_MAGIC	0x88786984	/* "XNET" */
     81
     82#define XPNET_VALID_MSG(_m)						     \
     83   ((XPNET_VERSION_MAJOR(_m->version) == XPNET_VERSION_MAJOR(XPNET_VERSION)) \
     84    && (msg->magic == XPNET_MAGIC))
     85
     86#define XPNET_DEVICE_NAME		"xp0"
     87
     88/*
     89 * When messages are queued with xpc_send_notify, a kmalloc'd buffer
     90 * of the following type is passed as a notification cookie.  When the
     91 * notification function is called, we use the cookie to decide
     92 * whether all outstanding message sends have completed.  The skb can
     93 * then be released.
     94 */
     95struct xpnet_pending_msg {
     96	struct sk_buff *skb;
     97	atomic_t use_count;
     98};
     99
    100static struct net_device *xpnet_device;
    101
    102/*
    103 * When we are notified of other partitions activating, we add them to
    104 * our bitmask of partitions to which we broadcast.
    105 */
    106static unsigned long *xpnet_broadcast_partitions;
    107/* protect above */
    108static DEFINE_SPINLOCK(xpnet_broadcast_lock);
    109
    110/*
    111 * Since the Block Transfer Engine (BTE) is being used for the transfer
    112 * and it relies upon cache-line size transfers, we need to reserve at
    113 * least one cache-line for head and tail alignment.  The BTE is
    114 * limited to 8MB transfers.
    115 *
    116 * Testing has shown that changing MTU to greater than 64KB has no effect
    117 * on TCP as the two sides negotiate a Max Segment Size that is limited
    118 * to 64K.  Other protocols May use packets greater than this, but for
    119 * now, the default is 64KB.
    120 */
    121#define XPNET_MAX_MTU (0x800000UL - L1_CACHE_BYTES)
    122/* 68 comes from min TCP+IP+MAC header */
    123#define XPNET_MIN_MTU 68
    124/* 32KB has been determined to be the ideal */
    125#define XPNET_DEF_MTU (0x8000UL)
    126
    127/*
    128 * The partid is encapsulated in the MAC address beginning in the following
    129 * octet and it consists of two octets.
    130 */
    131#define XPNET_PARTID_OCTET	2
    132
    133/* Define the XPNET debug device structures to be used with dev_dbg() et al */
    134
    135static struct device_driver xpnet_dbg_name = {
    136	.name = "xpnet"
    137};
    138
    139static struct device xpnet_dbg_subname = {
    140	.init_name = "",	/* set to "" */
    141	.driver = &xpnet_dbg_name
    142};
    143
    144static struct device *xpnet = &xpnet_dbg_subname;
    145
    146/*
    147 * Packet was recevied by XPC and forwarded to us.
    148 */
    149static void
    150xpnet_receive(short partid, int channel, struct xpnet_message *msg)
    151{
    152	struct sk_buff *skb;
    153	void *dst;
    154	enum xp_retval ret;
    155
    156	if (!XPNET_VALID_MSG(msg)) {
    157		/*
    158		 * Packet with a different XPC version.  Ignore.
    159		 */
    160		xpc_received(partid, channel, (void *)msg);
    161
    162		xpnet_device->stats.rx_errors++;
    163
    164		return;
    165	}
    166	dev_dbg(xpnet, "received 0x%lx, %d, %d, %d\n", msg->buf_pa, msg->size,
    167		msg->leadin_ignore, msg->tailout_ignore);
    168
    169	/* reserve an extra cache line */
    170	skb = dev_alloc_skb(msg->size + L1_CACHE_BYTES);
    171	if (!skb) {
    172		dev_err(xpnet, "failed on dev_alloc_skb(%d)\n",
    173			msg->size + L1_CACHE_BYTES);
    174
    175		xpc_received(partid, channel, (void *)msg);
    176
    177		xpnet_device->stats.rx_errors++;
    178
    179		return;
    180	}
    181
    182	/*
    183	 * The allocated skb has some reserved space.
    184	 * In order to use xp_remote_memcpy(), we need to get the
    185	 * skb->data pointer moved forward.
    186	 */
    187	skb_reserve(skb, (L1_CACHE_BYTES - ((u64)skb->data &
    188					    (L1_CACHE_BYTES - 1)) +
    189			  msg->leadin_ignore));
    190
    191	/*
    192	 * Update the tail pointer to indicate data actually
    193	 * transferred.
    194	 */
    195	skb_put(skb, (msg->size - msg->leadin_ignore - msg->tailout_ignore));
    196
    197	/*
    198	 * Move the data over from the other side.
    199	 */
    200	if ((XPNET_VERSION_MINOR(msg->version) == 1) &&
    201	    (msg->embedded_bytes != 0)) {
    202		dev_dbg(xpnet, "copying embedded message. memcpy(0x%p, 0x%p, "
    203			"%lu)\n", skb->data, &msg->data,
    204			(size_t)msg->embedded_bytes);
    205
    206		skb_copy_to_linear_data(skb, &msg->data,
    207					(size_t)msg->embedded_bytes);
    208	} else {
    209		dst = (void *)((u64)skb->data & ~(L1_CACHE_BYTES - 1));
    210		dev_dbg(xpnet, "transferring buffer to the skb->data area;\n\t"
    211			"xp_remote_memcpy(0x%p, 0x%p, %u)\n", dst,
    212					  (void *)msg->buf_pa, msg->size);
    213
    214		ret = xp_remote_memcpy(xp_pa(dst), msg->buf_pa, msg->size);
    215		if (ret != xpSuccess) {
    216			/*
    217			 * !!! Need better way of cleaning skb.  Currently skb
    218			 * !!! appears in_use and we can't just call
    219			 * !!! dev_kfree_skb.
    220			 */
    221			dev_err(xpnet, "xp_remote_memcpy(0x%p, 0x%p, 0x%x) "
    222				"returned error=0x%x\n", dst,
    223				(void *)msg->buf_pa, msg->size, ret);
    224
    225			xpc_received(partid, channel, (void *)msg);
    226
    227			xpnet_device->stats.rx_errors++;
    228
    229			return;
    230		}
    231	}
    232
    233	dev_dbg(xpnet, "<skb->head=0x%p skb->data=0x%p skb->tail=0x%p "
    234		"skb->end=0x%p skb->len=%d\n", (void *)skb->head,
    235		(void *)skb->data, skb_tail_pointer(skb), skb_end_pointer(skb),
    236		skb->len);
    237
    238	skb->protocol = eth_type_trans(skb, xpnet_device);
    239	skb->ip_summed = CHECKSUM_UNNECESSARY;
    240
    241	dev_dbg(xpnet, "passing skb to network layer\n"
    242		"\tskb->head=0x%p skb->data=0x%p skb->tail=0x%p "
    243		"skb->end=0x%p skb->len=%d\n",
    244		(void *)skb->head, (void *)skb->data, skb_tail_pointer(skb),
    245		skb_end_pointer(skb), skb->len);
    246
    247	xpnet_device->stats.rx_packets++;
    248	xpnet_device->stats.rx_bytes += skb->len + ETH_HLEN;
    249
    250	netif_rx(skb);
    251	xpc_received(partid, channel, (void *)msg);
    252}
    253
    254/*
    255 * This is the handler which XPC calls during any sort of change in
    256 * state or message reception on a connection.
    257 */
    258static void
    259xpnet_connection_activity(enum xp_retval reason, short partid, int channel,
    260			  void *data, void *key)
    261{
    262	DBUG_ON(partid < 0 || partid >= xp_max_npartitions);
    263	DBUG_ON(channel != XPC_NET_CHANNEL);
    264
    265	switch (reason) {
    266	case xpMsgReceived:	/* message received */
    267		DBUG_ON(data == NULL);
    268
    269		xpnet_receive(partid, channel, (struct xpnet_message *)data);
    270		break;
    271
    272	case xpConnected:	/* connection completed to a partition */
    273		spin_lock_bh(&xpnet_broadcast_lock);
    274		__set_bit(partid, xpnet_broadcast_partitions);
    275		spin_unlock_bh(&xpnet_broadcast_lock);
    276
    277		netif_carrier_on(xpnet_device);
    278
    279		dev_dbg(xpnet, "%s connected to partition %d\n",
    280			xpnet_device->name, partid);
    281		break;
    282
    283	default:
    284		spin_lock_bh(&xpnet_broadcast_lock);
    285		__clear_bit(partid, xpnet_broadcast_partitions);
    286		spin_unlock_bh(&xpnet_broadcast_lock);
    287
    288		if (bitmap_empty((unsigned long *)xpnet_broadcast_partitions,
    289				 xp_max_npartitions)) {
    290			netif_carrier_off(xpnet_device);
    291		}
    292
    293		dev_dbg(xpnet, "%s disconnected from partition %d\n",
    294			xpnet_device->name, partid);
    295		break;
    296	}
    297}
    298
    299static int
    300xpnet_dev_open(struct net_device *dev)
    301{
    302	enum xp_retval ret;
    303
    304	dev_dbg(xpnet, "calling xpc_connect(%d, 0x%p, NULL, %ld, %ld, %ld, "
    305		"%ld)\n", XPC_NET_CHANNEL, xpnet_connection_activity,
    306		(unsigned long)XPNET_MSG_SIZE,
    307		(unsigned long)XPNET_MSG_NENTRIES,
    308		(unsigned long)XPNET_MAX_KTHREADS,
    309		(unsigned long)XPNET_MAX_IDLE_KTHREADS);
    310
    311	ret = xpc_connect(XPC_NET_CHANNEL, xpnet_connection_activity, NULL,
    312			  XPNET_MSG_SIZE, XPNET_MSG_NENTRIES,
    313			  XPNET_MAX_KTHREADS, XPNET_MAX_IDLE_KTHREADS);
    314	if (ret != xpSuccess) {
    315		dev_err(xpnet, "ifconfig up of %s failed on XPC connect, "
    316			"ret=%d\n", dev->name, ret);
    317
    318		return -ENOMEM;
    319	}
    320
    321	dev_dbg(xpnet, "ifconfig up of %s; XPC connected\n", dev->name);
    322
    323	return 0;
    324}
    325
    326static int
    327xpnet_dev_stop(struct net_device *dev)
    328{
    329	xpc_disconnect(XPC_NET_CHANNEL);
    330
    331	dev_dbg(xpnet, "ifconfig down of %s; XPC disconnected\n", dev->name);
    332
    333	return 0;
    334}
    335
    336/*
    337 * Notification that the other end has received the message and
    338 * DMA'd the skb information.  At this point, they are done with
    339 * our side.  When all recipients are done processing, we
    340 * release the skb and then release our pending message structure.
    341 */
    342static void
    343xpnet_send_completed(enum xp_retval reason, short partid, int channel,
    344		     void *__qm)
    345{
    346	struct xpnet_pending_msg *queued_msg = (struct xpnet_pending_msg *)__qm;
    347
    348	DBUG_ON(queued_msg == NULL);
    349
    350	dev_dbg(xpnet, "message to %d notified with reason %d\n",
    351		partid, reason);
    352
    353	if (atomic_dec_return(&queued_msg->use_count) == 0) {
    354		dev_dbg(xpnet, "all acks for skb->head=-x%p\n",
    355			(void *)queued_msg->skb->head);
    356
    357		dev_kfree_skb_any(queued_msg->skb);
    358		kfree(queued_msg);
    359	}
    360}
    361
    362static void
    363xpnet_send(struct sk_buff *skb, struct xpnet_pending_msg *queued_msg,
    364	   u64 start_addr, u64 end_addr, u16 embedded_bytes, int dest_partid)
    365{
    366	u8 msg_buffer[XPNET_MSG_SIZE];
    367	struct xpnet_message *msg = (struct xpnet_message *)&msg_buffer;
    368	u16 msg_size = sizeof(struct xpnet_message);
    369	enum xp_retval ret;
    370
    371	msg->embedded_bytes = embedded_bytes;
    372	if (unlikely(embedded_bytes != 0)) {
    373		msg->version = XPNET_VERSION_EMBED;
    374		dev_dbg(xpnet, "calling memcpy(0x%p, 0x%p, 0x%lx)\n",
    375			&msg->data, skb->data, (size_t)embedded_bytes);
    376		skb_copy_from_linear_data(skb, &msg->data,
    377					  (size_t)embedded_bytes);
    378		msg_size += embedded_bytes - 1;
    379	} else {
    380		msg->version = XPNET_VERSION;
    381	}
    382	msg->magic = XPNET_MAGIC;
    383	msg->size = end_addr - start_addr;
    384	msg->leadin_ignore = (u64)skb->data - start_addr;
    385	msg->tailout_ignore = end_addr - (u64)skb_tail_pointer(skb);
    386	msg->buf_pa = xp_pa((void *)start_addr);
    387
    388	dev_dbg(xpnet, "sending XPC message to %d:%d\n"
    389		"msg->buf_pa=0x%lx, msg->size=%u, "
    390		"msg->leadin_ignore=%u, msg->tailout_ignore=%u\n",
    391		dest_partid, XPC_NET_CHANNEL, msg->buf_pa, msg->size,
    392		msg->leadin_ignore, msg->tailout_ignore);
    393
    394	atomic_inc(&queued_msg->use_count);
    395
    396	ret = xpc_send_notify(dest_partid, XPC_NET_CHANNEL, XPC_NOWAIT, msg,
    397			      msg_size, xpnet_send_completed, queued_msg);
    398	if (unlikely(ret != xpSuccess))
    399		atomic_dec(&queued_msg->use_count);
    400}
    401
    402/*
    403 * Network layer has formatted a packet (skb) and is ready to place it
    404 * "on the wire".  Prepare and send an xpnet_message to all partitions
    405 * which have connected with us and are targets of this packet.
    406 *
    407 * MAC-NOTE:  For the XPNET driver, the MAC address contains the
    408 * destination partid.  If the destination partid octets are 0xffff,
    409 * this packet is to be broadcast to all connected partitions.
    410 */
    411static netdev_tx_t
    412xpnet_dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
    413{
    414	struct xpnet_pending_msg *queued_msg;
    415	u64 start_addr, end_addr;
    416	short dest_partid;
    417	u16 embedded_bytes = 0;
    418
    419	dev_dbg(xpnet, ">skb->head=0x%p skb->data=0x%p skb->tail=0x%p "
    420		"skb->end=0x%p skb->len=%d\n", (void *)skb->head,
    421		(void *)skb->data, skb_tail_pointer(skb), skb_end_pointer(skb),
    422		skb->len);
    423
    424	if (skb->data[0] == 0x33) {
    425		dev_kfree_skb(skb);
    426		return NETDEV_TX_OK;	/* nothing needed to be done */
    427	}
    428
    429	/*
    430	 * The xpnet_pending_msg tracks how many outstanding
    431	 * xpc_send_notifies are relying on this skb.  When none
    432	 * remain, release the skb.
    433	 */
    434	queued_msg = kmalloc(sizeof(struct xpnet_pending_msg), GFP_ATOMIC);
    435	if (queued_msg == NULL) {
    436		dev_warn(xpnet, "failed to kmalloc %ld bytes; dropping "
    437			 "packet\n", sizeof(struct xpnet_pending_msg));
    438
    439		dev->stats.tx_errors++;
    440		dev_kfree_skb(skb);
    441		return NETDEV_TX_OK;
    442	}
    443
    444	/* get the beginning of the first cacheline and end of last */
    445	start_addr = ((u64)skb->data & ~(L1_CACHE_BYTES - 1));
    446	end_addr = L1_CACHE_ALIGN((u64)skb_tail_pointer(skb));
    447
    448	/* calculate how many bytes to embed in the XPC message */
    449	if (unlikely(skb->len <= XPNET_MSG_DATA_MAX)) {
    450		/* skb->data does fit so embed */
    451		embedded_bytes = skb->len;
    452	}
    453
    454	/*
    455	 * Since the send occurs asynchronously, we set the count to one
    456	 * and begin sending.  Any sends that happen to complete before
    457	 * we are done sending will not free the skb.  We will be left
    458	 * with that task during exit.  This also handles the case of
    459	 * a packet destined for a partition which is no longer up.
    460	 */
    461	atomic_set(&queued_msg->use_count, 1);
    462	queued_msg->skb = skb;
    463
    464	if (skb->data[0] == 0xff) {
    465		/* we are being asked to broadcast to all partitions */
    466		for_each_set_bit(dest_partid, xpnet_broadcast_partitions,
    467			     xp_max_npartitions) {
    468
    469			xpnet_send(skb, queued_msg, start_addr, end_addr,
    470				   embedded_bytes, dest_partid);
    471		}
    472	} else {
    473		dest_partid = (short)skb->data[XPNET_PARTID_OCTET + 1];
    474		dest_partid |= (short)skb->data[XPNET_PARTID_OCTET + 0] << 8;
    475
    476		if (dest_partid >= 0 &&
    477		    dest_partid < xp_max_npartitions &&
    478		    test_bit(dest_partid, xpnet_broadcast_partitions) != 0) {
    479
    480			xpnet_send(skb, queued_msg, start_addr, end_addr,
    481				   embedded_bytes, dest_partid);
    482		}
    483	}
    484
    485	dev->stats.tx_packets++;
    486	dev->stats.tx_bytes += skb->len;
    487
    488	if (atomic_dec_return(&queued_msg->use_count) == 0) {
    489		dev_kfree_skb(skb);
    490		kfree(queued_msg);
    491	}
    492
    493	return NETDEV_TX_OK;
    494}
    495
    496/*
    497 * Deal with transmit timeouts coming from the network layer.
    498 */
    499static void
    500xpnet_dev_tx_timeout(struct net_device *dev, unsigned int txqueue)
    501{
    502	dev->stats.tx_errors++;
    503}
    504
    505static const struct net_device_ops xpnet_netdev_ops = {
    506	.ndo_open		= xpnet_dev_open,
    507	.ndo_stop		= xpnet_dev_stop,
    508	.ndo_start_xmit		= xpnet_dev_hard_start_xmit,
    509	.ndo_tx_timeout		= xpnet_dev_tx_timeout,
    510	.ndo_set_mac_address 	= eth_mac_addr,
    511	.ndo_validate_addr	= eth_validate_addr,
    512};
    513
    514static int __init
    515xpnet_init(void)
    516{
    517	u8 addr[ETH_ALEN];
    518	int result;
    519
    520	if (!is_uv_system())
    521		return -ENODEV;
    522
    523	dev_info(xpnet, "registering network device %s\n", XPNET_DEVICE_NAME);
    524
    525	xpnet_broadcast_partitions = kcalloc(BITS_TO_LONGS(xp_max_npartitions),
    526					     sizeof(long),
    527					     GFP_KERNEL);
    528	if (xpnet_broadcast_partitions == NULL)
    529		return -ENOMEM;
    530
    531	/*
    532	 * use ether_setup() to init the majority of our device
    533	 * structure and then override the necessary pieces.
    534	 */
    535	xpnet_device = alloc_netdev(0, XPNET_DEVICE_NAME, NET_NAME_UNKNOWN,
    536				    ether_setup);
    537	if (xpnet_device == NULL) {
    538		kfree(xpnet_broadcast_partitions);
    539		return -ENOMEM;
    540	}
    541
    542	netif_carrier_off(xpnet_device);
    543
    544	xpnet_device->netdev_ops = &xpnet_netdev_ops;
    545	xpnet_device->mtu = XPNET_DEF_MTU;
    546	xpnet_device->min_mtu = XPNET_MIN_MTU;
    547	xpnet_device->max_mtu = XPNET_MAX_MTU;
    548
    549	memset(addr, 0, sizeof(addr));
    550	/*
    551	 * Multicast assumes the LSB of the first octet is set for multicast
    552	 * MAC addresses.  We chose the first octet of the MAC to be unlikely
    553	 * to collide with any vendor's officially issued MAC.
    554	 */
    555	addr[0] = 0x02;     /* locally administered, no OUI */
    556
    557	addr[XPNET_PARTID_OCTET + 1] = xp_partition_id;
    558	addr[XPNET_PARTID_OCTET + 0] = (xp_partition_id >> 8);
    559	eth_hw_addr_set(xpnet_device, addr);
    560
    561	/*
    562	 * ether_setup() sets this to a multicast device.  We are
    563	 * really not supporting multicast at this time.
    564	 */
    565	xpnet_device->flags &= ~IFF_MULTICAST;
    566
    567	/*
    568	 * No need to checksum as it is a DMA transfer.  The BTE will
    569	 * report an error if the data is not retrievable and the
    570	 * packet will be dropped.
    571	 */
    572	xpnet_device->features = NETIF_F_HW_CSUM;
    573
    574	result = register_netdev(xpnet_device);
    575	if (result != 0) {
    576		free_netdev(xpnet_device);
    577		kfree(xpnet_broadcast_partitions);
    578	}
    579
    580	return result;
    581}
    582
    583module_init(xpnet_init);
    584
    585static void __exit
    586xpnet_exit(void)
    587{
    588	dev_info(xpnet, "unregistering network device %s\n",
    589		 xpnet_device[0].name);
    590
    591	unregister_netdev(xpnet_device);
    592	free_netdev(xpnet_device);
    593	kfree(xpnet_broadcast_partitions);
    594}
    595
    596module_exit(xpnet_exit);
    597
    598MODULE_AUTHOR("Silicon Graphics, Inc.");
    599MODULE_DESCRIPTION("Cross Partition Network adapter (XPNET)");
    600MODULE_LICENSE("GPL");