2005-03-23 20:50:00 -07:00
|
|
|
/*
|
|
|
|
* This file is subject to the terms and conditions of the GNU General Public
|
|
|
|
* License. See the file "COPYING" in the main directory of this archive
|
|
|
|
* for more details.
|
|
|
|
*
|
2009-02-03 16:16:17 -07:00
|
|
|
* Copyright (C) 1999-2009 Silicon Graphics, Inc. All rights reserved.
|
2005-03-23 20:50:00 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Cross Partition Network Interface (XPNET) support
|
|
|
|
*
|
|
|
|
* XPNET provides a virtual network layered on top of the Cross
|
|
|
|
* Partition communication layer.
|
|
|
|
*
|
|
|
|
* XPNET provides direct point-to-point and broadcast-like support
|
|
|
|
* for an ethernet-like device. The ethernet broadcast medium is
|
|
|
|
* replaced with a point-to-point message structure which passes
|
|
|
|
* pointers to a DMA-capable block that a remote partition should
|
|
|
|
* retrieve and pass to the upper level networking layer.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2005-03-23 20:50:00 -07:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/etherdevice.h>
|
2008-04-22 13:46:56 -06:00
|
|
|
#include "xp.h"
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The message payload transferred by XPC.
|
|
|
|
*
|
|
|
|
* buf_pa is the physical address where the DMA should pull from.
|
|
|
|
*
|
|
|
|
* NOTE: for performance reasons, buf_pa should _ALWAYS_ begin on a
|
|
|
|
* cacheline boundary. To accomplish this, we record the number of
|
|
|
|
* bytes from the beginning of the first cacheline to the first useful
|
|
|
|
* byte of the skb (leadin_ignore) and the number of bytes from the
|
|
|
|
* last useful byte of the skb to the end of the last cacheline
|
|
|
|
* (tailout_ignore).
|
|
|
|
*
|
|
|
|
* size is the number of bytes to transfer which includes the skb->len
|
|
|
|
* (useful bytes of the senders skb) plus the leadin and tailout
|
|
|
|
*/
|
|
|
|
struct xpnet_message {
|
|
|
|
u16 version; /* Version for this message */
|
|
|
|
u16 embedded_bytes; /* #of bytes embedded in XPC message */
|
|
|
|
u32 magic; /* Special number indicating this is xpnet */
|
2008-07-29 23:34:16 -06:00
|
|
|
unsigned long buf_pa; /* phys address of buffer to retrieve */
|
2005-03-23 20:50:00 -07:00
|
|
|
u32 size; /* #of bytes in buffer */
|
|
|
|
u8 leadin_ignore; /* #of bytes to ignore at the beginning */
|
|
|
|
u8 tailout_ignore; /* #of bytes to ignore at the end */
|
|
|
|
unsigned char data; /* body of small packets */
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine the size of our message, the cacheline aligned size,
|
|
|
|
* and then the number of message will request from XPC.
|
|
|
|
*
|
|
|
|
* XPC expects each message to exist in an individual cacheline.
|
|
|
|
*/
|
2008-07-29 23:34:19 -06:00
|
|
|
#define XPNET_MSG_SIZE XPC_MSG_PAYLOAD_MAX_SIZE
|
2005-03-23 20:50:00 -07:00
|
|
|
#define XPNET_MSG_DATA_MAX \
|
2008-07-29 23:34:19 -06:00
|
|
|
(XPNET_MSG_SIZE - offsetof(struct xpnet_message, data))
|
|
|
|
#define XPNET_MSG_NENTRIES (PAGE_SIZE / XPC_MSG_MAX_SIZE)
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
#define XPNET_MAX_KTHREADS (XPNET_MSG_NENTRIES + 1)
|
|
|
|
#define XPNET_MAX_IDLE_KTHREADS (XPNET_MSG_NENTRIES + 1)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Version number of XPNET implementation. XPNET can always talk to versions
|
|
|
|
* with same major #, and never talk to versions with a different version.
|
|
|
|
*/
|
|
|
|
#define _XPNET_VERSION(_major, _minor) (((_major) << 4) | (_minor))
|
|
|
|
#define XPNET_VERSION_MAJOR(_v) ((_v) >> 4)
|
|
|
|
#define XPNET_VERSION_MINOR(_v) ((_v) & 0xf)
|
|
|
|
|
2008-04-22 13:50:17 -06:00
|
|
|
#define XPNET_VERSION _XPNET_VERSION(1, 0) /* version 1.0 */
|
|
|
|
#define XPNET_VERSION_EMBED _XPNET_VERSION(1, 1) /* version 1.1 */
|
2008-04-22 13:48:55 -06:00
|
|
|
#define XPNET_MAGIC 0x88786984 /* "XNET" */
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
#define XPNET_VALID_MSG(_m) \
|
|
|
|
((XPNET_VERSION_MAJOR(_m->version) == XPNET_VERSION_MAJOR(XPNET_VERSION)) \
|
|
|
|
&& (msg->magic == XPNET_MAGIC))
|
|
|
|
|
|
|
|
#define XPNET_DEVICE_NAME "xp0"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When messages are queued with xpc_send_notify, a kmalloc'd buffer
|
|
|
|
* of the following type is passed as a notification cookie. When the
|
|
|
|
* notification function is called, we use the cookie to decide
|
|
|
|
* whether all outstanding message sends have completed. The skb can
|
|
|
|
* then be released.
|
|
|
|
*/
|
|
|
|
struct xpnet_pending_msg {
|
|
|
|
struct sk_buff *skb;
|
|
|
|
atomic_t use_count;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct net_device *xpnet_device;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When we are notified of other partitions activating, we add them to
|
|
|
|
* our bitmask of partitions to which we broadcast.
|
|
|
|
*/
|
2008-07-29 23:34:12 -06:00
|
|
|
static unsigned long *xpnet_broadcast_partitions;
|
2005-03-23 20:50:00 -07:00
|
|
|
/* protect above */
|
2005-09-09 14:10:41 -06:00
|
|
|
static DEFINE_SPINLOCK(xpnet_broadcast_lock);
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Since the Block Transfer Engine (BTE) is being used for the transfer
|
|
|
|
* and it relies upon cache-line size transfers, we need to reserve at
|
|
|
|
* least one cache-line for head and tail alignment. The BTE is
|
|
|
|
* limited to 8MB transfers.
|
|
|
|
*
|
|
|
|
* Testing has shown that changing MTU to greater than 64KB has no effect
|
|
|
|
* on TCP as the two sides negotiate a Max Segment Size that is limited
|
|
|
|
* to 64K. Other protocols May use packets greater than this, but for
|
|
|
|
* now, the default is 64KB.
|
|
|
|
*/
|
|
|
|
#define XPNET_MAX_MTU (0x800000UL - L1_CACHE_BYTES)
|
|
|
|
/* 32KB has been determined to be the ideal */
|
|
|
|
#define XPNET_DEF_MTU (0x8000UL)
|
|
|
|
|
|
|
|
/*
|
2008-07-29 23:34:12 -06:00
|
|
|
* The partid is encapsulated in the MAC address beginning in the following
|
|
|
|
* octet and it consists of two octets.
|
2005-03-23 20:50:00 -07:00
|
|
|
*/
|
2008-07-29 23:34:12 -06:00
|
|
|
#define XPNET_PARTID_OCTET 2
|
|
|
|
|
|
|
|
/* Define the XPNET debug device structures to be used with dev_dbg() et al */
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
struct device_driver xpnet_dbg_name = {
|
|
|
|
.name = "xpnet"
|
|
|
|
};
|
|
|
|
|
|
|
|
struct device xpnet_dbg_subname = {
|
2009-01-06 11:44:37 -07:00
|
|
|
.init_name = "", /* set to "" */
|
2005-03-23 20:50:00 -07:00
|
|
|
.driver = &xpnet_dbg_name
|
|
|
|
};
|
|
|
|
|
|
|
|
struct device *xpnet = &xpnet_dbg_subname;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Packet was recevied by XPC and forwarded to us.
|
|
|
|
*/
|
|
|
|
static void
|
2008-05-12 15:02:03 -06:00
|
|
|
xpnet_receive(short partid, int channel, struct xpnet_message *msg)
|
2005-03-23 20:50:00 -07:00
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
2008-07-29 23:34:16 -06:00
|
|
|
void *dst;
|
2008-07-29 23:34:05 -06:00
|
|
|
enum xp_retval ret;
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
if (!XPNET_VALID_MSG(msg)) {
|
|
|
|
/*
|
|
|
|
* Packet with a different XPC version. Ignore.
|
|
|
|
*/
|
2008-04-22 13:48:55 -06:00
|
|
|
xpc_received(partid, channel, (void *)msg);
|
2005-03-23 20:50:00 -07:00
|
|
|
|
2009-01-07 19:05:11 -07:00
|
|
|
xpnet_device->stats.rx_errors++;
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
2008-07-29 23:34:16 -06:00
|
|
|
dev_dbg(xpnet, "received 0x%lx, %d, %d, %d\n", msg->buf_pa, msg->size,
|
|
|
|
msg->leadin_ignore, msg->tailout_ignore);
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
/* reserve an extra cache line */
|
|
|
|
skb = dev_alloc_skb(msg->size + L1_CACHE_BYTES);
|
|
|
|
if (!skb) {
|
|
|
|
dev_err(xpnet, "failed on dev_alloc_skb(%d)\n",
|
|
|
|
msg->size + L1_CACHE_BYTES);
|
|
|
|
|
2008-04-22 13:48:55 -06:00
|
|
|
xpc_received(partid, channel, (void *)msg);
|
2005-03-23 20:50:00 -07:00
|
|
|
|
2009-01-07 19:05:11 -07:00
|
|
|
xpnet_device->stats.rx_errors++;
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The allocated skb has some reserved space.
|
2008-07-29 23:34:05 -06:00
|
|
|
* In order to use xp_remote_memcpy(), we need to get the
|
2005-03-23 20:50:00 -07:00
|
|
|
* skb->data pointer moved forward.
|
|
|
|
*/
|
|
|
|
skb_reserve(skb, (L1_CACHE_BYTES - ((u64)skb->data &
|
|
|
|
(L1_CACHE_BYTES - 1)) +
|
|
|
|
msg->leadin_ignore));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Update the tail pointer to indicate data actually
|
|
|
|
* transferred.
|
|
|
|
*/
|
|
|
|
skb_put(skb, (msg->size - msg->leadin_ignore - msg->tailout_ignore));
|
|
|
|
|
|
|
|
/*
|
2006-10-03 14:21:02 -06:00
|
|
|
* Move the data over from the other side.
|
2005-03-23 20:50:00 -07:00
|
|
|
*/
|
|
|
|
if ((XPNET_VERSION_MINOR(msg->version) == 1) &&
|
2008-04-22 13:48:55 -06:00
|
|
|
(msg->embedded_bytes != 0)) {
|
2005-03-23 20:50:00 -07:00
|
|
|
dev_dbg(xpnet, "copying embedded message. memcpy(0x%p, 0x%p, "
|
|
|
|
"%lu)\n", skb->data, &msg->data,
|
2008-04-22 13:48:55 -06:00
|
|
|
(size_t)msg->embedded_bytes);
|
2005-03-23 20:50:00 -07:00
|
|
|
|
2008-04-22 13:48:55 -06:00
|
|
|
skb_copy_to_linear_data(skb, &msg->data,
|
|
|
|
(size_t)msg->embedded_bytes);
|
2005-03-23 20:50:00 -07:00
|
|
|
} else {
|
2008-07-29 23:34:16 -06:00
|
|
|
dst = (void *)((u64)skb->data & ~(L1_CACHE_BYTES - 1));
|
2005-03-23 20:50:00 -07:00
|
|
|
dev_dbg(xpnet, "transferring buffer to the skb->data area;\n\t"
|
2008-07-29 23:34:16 -06:00
|
|
|
"xp_remote_memcpy(0x%p, 0x%p, %hu)\n", dst,
|
2008-07-29 23:34:05 -06:00
|
|
|
(void *)msg->buf_pa, msg->size);
|
2005-03-23 20:50:00 -07:00
|
|
|
|
2008-07-29 23:34:16 -06:00
|
|
|
ret = xp_remote_memcpy(xp_pa(dst), msg->buf_pa, msg->size);
|
2008-07-29 23:34:05 -06:00
|
|
|
if (ret != xpSuccess) {
|
2008-04-22 13:50:17 -06:00
|
|
|
/*
|
2008-07-29 23:34:14 -06:00
|
|
|
* !!! Need better way of cleaning skb. Currently skb
|
|
|
|
* !!! appears in_use and we can't just call
|
|
|
|
* !!! dev_kfree_skb.
|
2008-04-22 13:50:17 -06:00
|
|
|
*/
|
2008-07-29 23:34:05 -06:00
|
|
|
dev_err(xpnet, "xp_remote_memcpy(0x%p, 0x%p, 0x%hx) "
|
2008-07-29 23:34:16 -06:00
|
|
|
"returned error=0x%x\n", dst,
|
2008-07-29 23:34:05 -06:00
|
|
|
(void *)msg->buf_pa, msg->size, ret);
|
2005-03-23 20:50:00 -07:00
|
|
|
|
2008-04-22 13:48:55 -06:00
|
|
|
xpc_received(partid, channel, (void *)msg);
|
2005-03-23 20:50:00 -07:00
|
|
|
|
2009-01-07 19:05:11 -07:00
|
|
|
xpnet_device->stats.rx_errors++;
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_dbg(xpnet, "<skb->head=0x%p skb->data=0x%p skb->tail=0x%p "
|
2008-04-22 13:48:55 -06:00
|
|
|
"skb->end=0x%p skb->len=%d\n", (void *)skb->head,
|
2007-04-19 21:43:29 -06:00
|
|
|
(void *)skb->data, skb_tail_pointer(skb), skb_end_pointer(skb),
|
2005-03-23 20:50:00 -07:00
|
|
|
skb->len);
|
|
|
|
|
|
|
|
skb->protocol = eth_type_trans(skb, xpnet_device);
|
|
|
|
skb->ip_summed = CHECKSUM_UNNECESSARY;
|
|
|
|
|
2007-10-18 04:06:30 -06:00
|
|
|
dev_dbg(xpnet, "passing skb to network layer\n"
|
2009-07-06 14:05:40 -06:00
|
|
|
"\tskb->head=0x%p skb->data=0x%p skb->tail=0x%p "
|
2007-10-18 04:06:30 -06:00
|
|
|
"skb->end=0x%p skb->len=%d\n",
|
2007-04-19 21:29:13 -06:00
|
|
|
(void *)skb->head, (void *)skb->data, skb_tail_pointer(skb),
|
2007-04-19 21:43:29 -06:00
|
|
|
skb_end_pointer(skb), skb->len);
|
2005-03-23 20:50:00 -07:00
|
|
|
|
2009-01-07 19:05:11 -07:00
|
|
|
xpnet_device->stats.rx_packets++;
|
|
|
|
xpnet_device->stats.rx_bytes += skb->len + ETH_HLEN;
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
netif_rx_ni(skb);
|
2008-04-22 13:48:55 -06:00
|
|
|
xpc_received(partid, channel, (void *)msg);
|
2005-03-23 20:50:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is the handler which XPC calls during any sort of change in
|
|
|
|
* state or message reception on a connection.
|
|
|
|
*/
|
|
|
|
static void
|
2008-05-12 15:02:03 -06:00
|
|
|
xpnet_connection_activity(enum xp_retval reason, short partid, int channel,
|
2005-03-23 20:50:00 -07:00
|
|
|
void *data, void *key)
|
|
|
|
{
|
2008-07-29 23:34:04 -06:00
|
|
|
DBUG_ON(partid < 0 || partid >= xp_max_npartitions);
|
2005-03-23 20:50:00 -07:00
|
|
|
DBUG_ON(channel != XPC_NET_CHANNEL);
|
|
|
|
|
2008-04-22 13:48:55 -06:00
|
|
|
switch (reason) {
|
2008-05-12 15:02:02 -06:00
|
|
|
case xpMsgReceived: /* message received */
|
2005-03-23 20:50:00 -07:00
|
|
|
DBUG_ON(data == NULL);
|
|
|
|
|
2008-04-22 13:48:55 -06:00
|
|
|
xpnet_receive(partid, channel, (struct xpnet_message *)data);
|
2005-03-23 20:50:00 -07:00
|
|
|
break;
|
|
|
|
|
2008-05-12 15:02:02 -06:00
|
|
|
case xpConnected: /* connection completed to a partition */
|
2005-03-23 20:50:00 -07:00
|
|
|
spin_lock_bh(&xpnet_broadcast_lock);
|
2008-07-29 23:34:12 -06:00
|
|
|
__set_bit(partid, xpnet_broadcast_partitions);
|
2005-03-23 20:50:00 -07:00
|
|
|
spin_unlock_bh(&xpnet_broadcast_lock);
|
|
|
|
|
|
|
|
netif_carrier_on(xpnet_device);
|
|
|
|
|
2008-07-29 23:34:12 -06:00
|
|
|
dev_dbg(xpnet, "%s connected to partition %d\n",
|
|
|
|
xpnet_device->name, partid);
|
2005-03-23 20:50:00 -07:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
spin_lock_bh(&xpnet_broadcast_lock);
|
2008-07-29 23:34:12 -06:00
|
|
|
__clear_bit(partid, xpnet_broadcast_partitions);
|
2005-03-23 20:50:00 -07:00
|
|
|
spin_unlock_bh(&xpnet_broadcast_lock);
|
|
|
|
|
2008-07-29 23:34:12 -06:00
|
|
|
if (bitmap_empty((unsigned long *)xpnet_broadcast_partitions,
|
|
|
|
xp_max_npartitions)) {
|
2005-03-23 20:50:00 -07:00
|
|
|
netif_carrier_off(xpnet_device);
|
2008-07-29 23:34:12 -06:00
|
|
|
}
|
2005-03-23 20:50:00 -07:00
|
|
|
|
2008-07-29 23:34:12 -06:00
|
|
|
dev_dbg(xpnet, "%s disconnected from partition %d\n",
|
|
|
|
xpnet_device->name, partid);
|
2005-03-23 20:50:00 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xpnet_dev_open(struct net_device *dev)
|
|
|
|
{
|
2008-05-12 15:02:02 -06:00
|
|
|
enum xp_retval ret;
|
2005-03-23 20:50:00 -07:00
|
|
|
|
2007-05-10 12:47:38 -06:00
|
|
|
dev_dbg(xpnet, "calling xpc_connect(%d, 0x%p, NULL, %ld, %ld, %ld, "
|
|
|
|
"%ld)\n", XPC_NET_CHANNEL, xpnet_connection_activity,
|
2008-07-29 23:34:16 -06:00
|
|
|
(unsigned long)XPNET_MSG_SIZE,
|
|
|
|
(unsigned long)XPNET_MSG_NENTRIES,
|
|
|
|
(unsigned long)XPNET_MAX_KTHREADS,
|
|
|
|
(unsigned long)XPNET_MAX_IDLE_KTHREADS);
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
ret = xpc_connect(XPC_NET_CHANNEL, xpnet_connection_activity, NULL,
|
|
|
|
XPNET_MSG_SIZE, XPNET_MSG_NENTRIES,
|
|
|
|
XPNET_MAX_KTHREADS, XPNET_MAX_IDLE_KTHREADS);
|
2008-05-12 15:02:02 -06:00
|
|
|
if (ret != xpSuccess) {
|
2005-03-23 20:50:00 -07:00
|
|
|
dev_err(xpnet, "ifconfig up of %s failed on XPC connect, "
|
|
|
|
"ret=%d\n", dev->name, ret);
|
|
|
|
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_dbg(xpnet, "ifconfig up of %s; XPC connected\n", dev->name);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xpnet_dev_stop(struct net_device *dev)
|
|
|
|
{
|
|
|
|
xpc_disconnect(XPC_NET_CHANNEL);
|
|
|
|
|
|
|
|
dev_dbg(xpnet, "ifconfig down of %s; XPC disconnected\n", dev->name);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
xpnet_dev_change_mtu(struct net_device *dev, int new_mtu)
|
|
|
|
{
|
|
|
|
/* 68 comes from min TCP+IP+MAC header */
|
|
|
|
if ((new_mtu < 68) || (new_mtu > XPNET_MAX_MTU)) {
|
|
|
|
dev_err(xpnet, "ifconfig %s mtu %d failed; value must be "
|
|
|
|
"between 68 and %ld\n", dev->name, new_mtu,
|
|
|
|
XPNET_MAX_MTU);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev->mtu = new_mtu;
|
|
|
|
dev_dbg(xpnet, "ifconfig %s mtu set to %d\n", dev->name, new_mtu);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Notification that the other end has received the message and
|
|
|
|
* DMA'd the skb information. At this point, they are done with
|
|
|
|
* our side. When all recipients are done processing, we
|
|
|
|
* release the skb and then release our pending message structure.
|
|
|
|
*/
|
|
|
|
static void
|
2008-05-12 15:02:03 -06:00
|
|
|
xpnet_send_completed(enum xp_retval reason, short partid, int channel,
|
2008-04-22 13:48:55 -06:00
|
|
|
void *__qm)
|
2005-03-23 20:50:00 -07:00
|
|
|
{
|
2008-04-22 13:48:55 -06:00
|
|
|
struct xpnet_pending_msg *queued_msg = (struct xpnet_pending_msg *)__qm;
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
DBUG_ON(queued_msg == NULL);
|
|
|
|
|
|
|
|
dev_dbg(xpnet, "message to %d notified with reason %d\n",
|
|
|
|
partid, reason);
|
|
|
|
|
|
|
|
if (atomic_dec_return(&queued_msg->use_count) == 0) {
|
|
|
|
dev_dbg(xpnet, "all acks for skb->head=-x%p\n",
|
2008-04-22 13:48:55 -06:00
|
|
|
(void *)queued_msg->skb->head);
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
dev_kfree_skb_any(queued_msg->skb);
|
|
|
|
kfree(queued_msg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-29 23:34:12 -06:00
|
|
|
static void
|
|
|
|
xpnet_send(struct sk_buff *skb, struct xpnet_pending_msg *queued_msg,
|
|
|
|
u64 start_addr, u64 end_addr, u16 embedded_bytes, int dest_partid)
|
|
|
|
{
|
|
|
|
u8 msg_buffer[XPNET_MSG_SIZE];
|
|
|
|
struct xpnet_message *msg = (struct xpnet_message *)&msg_buffer;
|
2008-07-29 23:34:19 -06:00
|
|
|
u16 msg_size = sizeof(struct xpnet_message);
|
2008-07-29 23:34:12 -06:00
|
|
|
enum xp_retval ret;
|
|
|
|
|
|
|
|
msg->embedded_bytes = embedded_bytes;
|
|
|
|
if (unlikely(embedded_bytes != 0)) {
|
|
|
|
msg->version = XPNET_VERSION_EMBED;
|
|
|
|
dev_dbg(xpnet, "calling memcpy(0x%p, 0x%p, 0x%lx)\n",
|
|
|
|
&msg->data, skb->data, (size_t)embedded_bytes);
|
|
|
|
skb_copy_from_linear_data(skb, &msg->data,
|
|
|
|
(size_t)embedded_bytes);
|
2008-07-29 23:34:19 -06:00
|
|
|
msg_size += embedded_bytes - 1;
|
2008-07-29 23:34:12 -06:00
|
|
|
} else {
|
|
|
|
msg->version = XPNET_VERSION;
|
|
|
|
}
|
|
|
|
msg->magic = XPNET_MAGIC;
|
|
|
|
msg->size = end_addr - start_addr;
|
|
|
|
msg->leadin_ignore = (u64)skb->data - start_addr;
|
|
|
|
msg->tailout_ignore = end_addr - (u64)skb_tail_pointer(skb);
|
2008-07-29 23:34:16 -06:00
|
|
|
msg->buf_pa = xp_pa((void *)start_addr);
|
2008-07-29 23:34:12 -06:00
|
|
|
|
|
|
|
dev_dbg(xpnet, "sending XPC message to %d:%d\n"
|
2009-07-06 14:05:40 -06:00
|
|
|
"msg->buf_pa=0x%lx, msg->size=%u, "
|
2008-07-29 23:34:12 -06:00
|
|
|
"msg->leadin_ignore=%u, msg->tailout_ignore=%u\n",
|
2008-07-29 23:34:16 -06:00
|
|
|
dest_partid, XPC_NET_CHANNEL, msg->buf_pa, msg->size,
|
|
|
|
msg->leadin_ignore, msg->tailout_ignore);
|
2008-07-29 23:34:12 -06:00
|
|
|
|
|
|
|
atomic_inc(&queued_msg->use_count);
|
|
|
|
|
|
|
|
ret = xpc_send_notify(dest_partid, XPC_NET_CHANNEL, XPC_NOWAIT, msg,
|
2008-07-29 23:34:19 -06:00
|
|
|
msg_size, xpnet_send_completed, queued_msg);
|
2008-07-29 23:34:12 -06:00
|
|
|
if (unlikely(ret != xpSuccess))
|
|
|
|
atomic_dec(&queued_msg->use_count);
|
|
|
|
}
|
|
|
|
|
2005-03-23 20:50:00 -07:00
|
|
|
/*
|
|
|
|
* Network layer has formatted a packet (skb) and is ready to place it
|
|
|
|
* "on the wire". Prepare and send an xpnet_message to all partitions
|
|
|
|
* which have connected with us and are targets of this packet.
|
|
|
|
*
|
|
|
|
* MAC-NOTE: For the XPNET driver, the MAC address contains the
|
2008-07-29 23:34:12 -06:00
|
|
|
* destination partid. If the destination partid octets are 0xffff,
|
|
|
|
* this packet is to be broadcast to all connected partitions.
|
2005-03-23 20:50:00 -07:00
|
|
|
*/
|
|
|
|
static int
|
|
|
|
xpnet_dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct xpnet_pending_msg *queued_msg;
|
|
|
|
u64 start_addr, end_addr;
|
2008-05-12 15:02:03 -06:00
|
|
|
short dest_partid;
|
2008-07-29 23:34:12 -06:00
|
|
|
u16 embedded_bytes = 0;
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
dev_dbg(xpnet, ">skb->head=0x%p skb->data=0x%p skb->tail=0x%p "
|
2008-04-22 13:48:55 -06:00
|
|
|
"skb->end=0x%p skb->len=%d\n", (void *)skb->head,
|
2007-04-19 21:43:29 -06:00
|
|
|
(void *)skb->data, skb_tail_pointer(skb), skb_end_pointer(skb),
|
2005-03-23 20:50:00 -07:00
|
|
|
skb->len);
|
|
|
|
|
2008-07-29 23:34:12 -06:00
|
|
|
if (skb->data[0] == 0x33) {
|
|
|
|
dev_kfree_skb(skb);
|
2009-06-23 00:03:08 -06:00
|
|
|
return NETDEV_TX_OK; /* nothing needed to be done */
|
2008-07-29 23:34:12 -06:00
|
|
|
}
|
|
|
|
|
2005-03-23 20:50:00 -07:00
|
|
|
/*
|
|
|
|
* The xpnet_pending_msg tracks how many outstanding
|
|
|
|
* xpc_send_notifies are relying on this skb. When none
|
|
|
|
* remain, release the skb.
|
|
|
|
*/
|
|
|
|
queued_msg = kmalloc(sizeof(struct xpnet_pending_msg), GFP_ATOMIC);
|
|
|
|
if (queued_msg == NULL) {
|
|
|
|
dev_warn(xpnet, "failed to kmalloc %ld bytes; dropping "
|
2008-04-22 13:48:55 -06:00
|
|
|
"packet\n", sizeof(struct xpnet_pending_msg));
|
2005-03-23 20:50:00 -07:00
|
|
|
|
2009-01-07 19:05:11 -07:00
|
|
|
dev->stats.tx_errors++;
|
2009-06-11 21:00:35 -06:00
|
|
|
dev_kfree_skb(skb);
|
|
|
|
return NETDEV_TX_OK;
|
2005-03-23 20:50:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* get the beginning of the first cacheline and end of last */
|
2008-04-22 13:48:55 -06:00
|
|
|
start_addr = ((u64)skb->data & ~(L1_CACHE_BYTES - 1));
|
2007-04-19 21:29:13 -06:00
|
|
|
end_addr = L1_CACHE_ALIGN((u64)skb_tail_pointer(skb));
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
/* calculate how many bytes to embed in the XPC message */
|
|
|
|
if (unlikely(skb->len <= XPNET_MSG_DATA_MAX)) {
|
|
|
|
/* skb->data does fit so embed */
|
|
|
|
embedded_bytes = skb->len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since the send occurs asynchronously, we set the count to one
|
|
|
|
* and begin sending. Any sends that happen to complete before
|
|
|
|
* we are done sending will not free the skb. We will be left
|
|
|
|
* with that task during exit. This also handles the case of
|
|
|
|
* a packet destined for a partition which is no longer up.
|
|
|
|
*/
|
|
|
|
atomic_set(&queued_msg->use_count, 1);
|
|
|
|
queued_msg->skb = skb;
|
|
|
|
|
2008-07-29 23:34:12 -06:00
|
|
|
if (skb->data[0] == 0xff) {
|
2005-03-23 20:50:00 -07:00
|
|
|
/* we are being asked to broadcast to all partitions */
|
2010-03-05 14:41:37 -07:00
|
|
|
for_each_set_bit(dest_partid, xpnet_broadcast_partitions,
|
2008-07-29 23:34:12 -06:00
|
|
|
xp_max_npartitions) {
|
2005-03-23 20:50:00 -07:00
|
|
|
|
2008-07-29 23:34:12 -06:00
|
|
|
xpnet_send(skb, queued_msg, start_addr, end_addr,
|
|
|
|
embedded_bytes, dest_partid);
|
2005-03-23 20:50:00 -07:00
|
|
|
}
|
2008-07-29 23:34:12 -06:00
|
|
|
} else {
|
|
|
|
dest_partid = (short)skb->data[XPNET_PARTID_OCTET + 1];
|
|
|
|
dest_partid |= (short)skb->data[XPNET_PARTID_OCTET + 0] << 8;
|
2005-03-23 20:50:00 -07:00
|
|
|
|
2008-07-29 23:34:12 -06:00
|
|
|
if (dest_partid >= 0 &&
|
|
|
|
dest_partid < xp_max_npartitions &&
|
|
|
|
test_bit(dest_partid, xpnet_broadcast_partitions) != 0) {
|
2005-03-23 20:50:00 -07:00
|
|
|
|
2008-07-29 23:34:12 -06:00
|
|
|
xpnet_send(skb, queued_msg, start_addr, end_addr,
|
|
|
|
embedded_bytes, dest_partid);
|
2005-03-23 20:50:00 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (atomic_dec_return(&queued_msg->use_count) == 0) {
|
|
|
|
dev_kfree_skb(skb);
|
|
|
|
kfree(queued_msg);
|
|
|
|
}
|
|
|
|
|
2009-01-07 19:05:11 -07:00
|
|
|
dev->stats.tx_packets++;
|
|
|
|
dev->stats.tx_bytes += skb->len;
|
2005-03-23 20:50:00 -07:00
|
|
|
|
2009-06-23 00:03:08 -06:00
|
|
|
return NETDEV_TX_OK;
|
2005-03-23 20:50:00 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Deal with transmit timeouts coming from the network layer.
|
|
|
|
*/
|
|
|
|
static void
|
2008-04-22 13:48:55 -06:00
|
|
|
xpnet_dev_tx_timeout(struct net_device *dev)
|
2005-03-23 20:50:00 -07:00
|
|
|
{
|
2009-01-07 19:05:11 -07:00
|
|
|
dev->stats.tx_errors++;
|
2005-03-23 20:50:00 -07:00
|
|
|
}
|
|
|
|
|
2009-01-07 19:05:11 -07:00
|
|
|
static const struct net_device_ops xpnet_netdev_ops = {
|
|
|
|
.ndo_open = xpnet_dev_open,
|
|
|
|
.ndo_stop = xpnet_dev_stop,
|
|
|
|
.ndo_start_xmit = xpnet_dev_hard_start_xmit,
|
|
|
|
.ndo_change_mtu = xpnet_dev_change_mtu,
|
|
|
|
.ndo_tx_timeout = xpnet_dev_tx_timeout,
|
|
|
|
.ndo_set_mac_address = eth_mac_addr,
|
|
|
|
.ndo_validate_addr = eth_validate_addr,
|
|
|
|
};
|
|
|
|
|
2005-03-23 20:50:00 -07:00
|
|
|
static int __init
|
|
|
|
xpnet_init(void)
|
|
|
|
{
|
2008-07-29 23:34:12 -06:00
|
|
|
int result;
|
2005-03-23 20:50:00 -07:00
|
|
|
|
2008-07-29 23:34:12 -06:00
|
|
|
if (!is_shub() && !is_uv())
|
2005-09-08 09:46:58 -06:00
|
|
|
return -ENODEV;
|
|
|
|
|
2005-03-23 20:50:00 -07:00
|
|
|
dev_info(xpnet, "registering network device %s\n", XPNET_DEVICE_NAME);
|
|
|
|
|
2008-07-29 23:34:12 -06:00
|
|
|
xpnet_broadcast_partitions = kzalloc(BITS_TO_LONGS(xp_max_npartitions) *
|
|
|
|
sizeof(long), GFP_KERNEL);
|
|
|
|
if (xpnet_broadcast_partitions == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2005-03-23 20:50:00 -07:00
|
|
|
/*
|
|
|
|
* use ether_setup() to init the majority of our device
|
|
|
|
* structure and then override the necessary pieces.
|
|
|
|
*/
|
2009-01-07 19:05:11 -07:00
|
|
|
xpnet_device = alloc_netdev(0, XPNET_DEVICE_NAME, ether_setup);
|
2008-07-29 23:34:12 -06:00
|
|
|
if (xpnet_device == NULL) {
|
|
|
|
kfree(xpnet_broadcast_partitions);
|
2005-03-23 20:50:00 -07:00
|
|
|
return -ENOMEM;
|
2008-07-29 23:34:12 -06:00
|
|
|
}
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
netif_carrier_off(xpnet_device);
|
|
|
|
|
2009-02-03 16:16:17 -07:00
|
|
|
xpnet_device->netdev_ops = &xpnet_netdev_ops;
|
2005-03-23 20:50:00 -07:00
|
|
|
xpnet_device->mtu = XPNET_DEF_MTU;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Multicast assumes the LSB of the first octet is set for multicast
|
|
|
|
* MAC addresses. We chose the first octet of the MAC to be unlikely
|
|
|
|
* to collide with any vendor's officially issued MAC.
|
|
|
|
*/
|
2008-07-29 23:34:12 -06:00
|
|
|
xpnet_device->dev_addr[0] = 0x02; /* locally administered, no OUI */
|
|
|
|
|
2008-07-29 23:34:16 -06:00
|
|
|
xpnet_device->dev_addr[XPNET_PARTID_OCTET + 1] = xp_partition_id;
|
|
|
|
xpnet_device->dev_addr[XPNET_PARTID_OCTET + 0] = (xp_partition_id >> 8);
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* ether_setup() sets this to a multicast device. We are
|
|
|
|
* really not supporting multicast at this time.
|
|
|
|
*/
|
|
|
|
xpnet_device->flags &= ~IFF_MULTICAST;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* No need to checksum as it is a DMA transfer. The BTE will
|
|
|
|
* report an error if the data is not retrievable and the
|
|
|
|
* packet will be dropped.
|
|
|
|
*/
|
|
|
|
xpnet_device->features = NETIF_F_NO_CSUM;
|
|
|
|
|
|
|
|
result = register_netdev(xpnet_device);
|
2008-07-29 23:34:12 -06:00
|
|
|
if (result != 0) {
|
2005-03-23 20:50:00 -07:00
|
|
|
free_netdev(xpnet_device);
|
2008-07-29 23:34:12 -06:00
|
|
|
kfree(xpnet_broadcast_partitions);
|
|
|
|
}
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2008-04-22 13:48:55 -06:00
|
|
|
module_init(xpnet_init);
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
static void __exit
|
|
|
|
xpnet_exit(void)
|
|
|
|
{
|
|
|
|
dev_info(xpnet, "unregistering network device %s\n",
|
2008-04-22 13:48:55 -06:00
|
|
|
xpnet_device[0].name);
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
unregister_netdev(xpnet_device);
|
|
|
|
free_netdev(xpnet_device);
|
2008-07-29 23:34:12 -06:00
|
|
|
kfree(xpnet_broadcast_partitions);
|
2005-03-23 20:50:00 -07:00
|
|
|
}
|
|
|
|
|
2008-04-22 13:48:55 -06:00
|
|
|
module_exit(xpnet_exit);
|
2005-03-23 20:50:00 -07:00
|
|
|
|
|
|
|
MODULE_AUTHOR("Silicon Graphics, Inc.");
|
|
|
|
MODULE_DESCRIPTION("Cross Partition Network adapter (XPNET)");
|
|
|
|
MODULE_LICENSE("GPL");
|