[Patch 4/5] run drivers/misc/xp through scripts/Lindent

dcn
2008-03-25T19:27:51Z

[-- Attachment #1: Lindent --]
[-- Type: text/plain, Size: 163773 bytes --]

Ran patches through scripts/Lindent.

Signed-off-by: Dean Nelson <dcn@sgi.com>

---

drivers/misc/xp/xp.h | 115 ++++------
drivers/misc/xp/xp_main.c | 109 ++++------
drivers/misc/xp/xp_sn2.c | 52 ++--
drivers/misc/xp/xp_uv.c | 7
drivers/misc/xp/xpc.h | 368 ++++++++++++++--------------------
drivers/misc/xp/xpc_channel.c | 379 +++++++++++++-----------------------
drivers/misc/xp/xpc_main.c | 329 +++++++++++++------------------
drivers/misc/xp/xpc_partition.c | 168 +++++----------
drivers/misc/xp/xpnet.c | 95 +++------
9 files changed, 661 insertions(+), 961 deletions(-)

Index: linux-2.6/drivers/misc/xp/xp.h
===================================================================
--- linux-2.6.orig/drivers/misc/xp/xp.h 2008-03-21 13:30:52.030174502 -0500
+++ linux-2.6/drivers/misc/xp/xp.h 2008-03-23 08:43:19.628746640 -0500
@@ -6,16 +6,13 @@
* Copyright (C) 2004-2008 Silicon Graphics, Inc. All rights reserved.
*/

-
/*
* External Cross Partition (XP) structures and defines.
*/

-
#ifndef _DRIVERS_MISC_XP_XP_H
#define _DRIVERS_MISC_XP_XP_H

-
#include <linux/cache.h>
#include <linux/hardirq.h>
#include <linux/mutex.h>
@@ -35,14 +32,12 @@
#error architecture is NOT supported
#endif

-
#ifdef USE_DBUG_ON
#define DBUG_ON(condition) BUG_ON(condition)
#else
#define DBUG_ON(condition)
#endif

-
#ifndef is_shub1
#define is_shub1() 0
#endif
@@ -59,7 +54,6 @@
#define is_uv() 0
#endif

-
/*
* Define the maximum number of logically defined partitions the system
* can support. It is constrained by the maximum number of hardware
@@ -78,10 +72,9 @@
#error XP_NPARTITIONS exceeds MAXIMUM possible.
#endif

-#define XP_MIN_PARTID 1 /* inclusive */
+#define XP_MIN_PARTID 1 /* inclusive */
#define XP_MAX_PARTID (XP_NPARTITIONS - 1) /* inclusive */

-
/*
* XPC establishes channel connections between the local partition and any
* other partition that is currently up. Over these channels, kernel-level
@@ -107,7 +100,6 @@
#error XPC_NCHANNELS exceeds MAXIMUM possible.
#endif

-
/*
* The format of an XPC message is as follows:
*
@@ -145,12 +137,10 @@ struct xpc_msg {
u64 payload; /* user defined portion of message */
};

-
#define XPC_MSG_PAYLOAD_OFFSET (u64) (&((struct xpc_msg *)0)->payload)
#define XPC_MSG_SIZE(_payload_size) \
L1_CACHE_ALIGN(XPC_MSG_PAYLOAD_OFFSET + (_payload_size))

-
/*
* Define the return values and values passed to user's callout functions.
* (It is important to add new value codes at the end just preceding
@@ -237,7 +227,6 @@ enum xp_retval {
xpUnknownReason /* 56: unknown reason (must be last in list) */
};

-
/* the following are valid xp_set_amo() ops */
#define XP_AMO_OR 1 /* set variable to (variable | operand) */
#define XP_AMO_AND 2 /* set variable to (variable & operand) */
@@ -252,7 +241,6 @@ enum xp_retval {
#define XP_MEMPROT_ALLOW_CPU_MEM 2
#define XP_MEMPROT_ALLOW_ALL 3 /* Shub 1.1 only */

-
/*
* Define the callout function types used by XPC to update the user on
* connection activity and state changes (via the user function registered by
@@ -357,12 +345,11 @@ enum xp_retval {
* =====================+================================+=====================
*/

-typedef void (*xpc_channel_func)(enum xp_retval reason, short partid,
- int ch_number, void *data, void *key);
-
-typedef void (*xpc_notify_func)(enum xp_retval reason, short partid,
- int ch_number, void *key);
+typedef void (*xpc_channel_func) (enum xp_retval reason, short partid,
+ int ch_number, void *data, void *key);

+typedef void (*xpc_notify_func) (enum xp_retval reason, short partid,
+ int ch_number, void *key);

/*
* The following is a registration entry. There is a global array of these,
@@ -380,50 +367,45 @@ typedef void (*xpc_notify_func)(enum xp_
*/
struct xpc_registration {
struct mutex mutex;
- xpc_channel_func func; /* function to call */
- void *key; /* pointer to user's key */
- u16 nentries; /* #of msg entries in local msg queue */
- u16 msg_size; /* message queue's message size */
- u32 assigned_limit; /* limit on #of assigned kthreads */
- u32 idle_limit; /* limit on #of idle kthreads */
+ xpc_channel_func func; /* function to call */
+ void *key; /* pointer to user's key */
+ u16 nentries; /* #of msg entries in local msg queue */
+ u16 msg_size; /* message queue's message size */
+ u32 assigned_limit; /* limit on #of assigned kthreads */
+ u32 idle_limit; /* limit on #of idle kthreads */
} ____cacheline_aligned;

-
#define XPC_CHANNEL_REGISTERED(_c) (xpc_registrations[_c].func != NULL)

-
/* the following are valid xpc_allocate() flags */
-#define XPC_WAIT 0 /* wait flag */
-#define XPC_NOWAIT 1 /* no wait flag */
-
+#define XPC_WAIT 0 /* wait flag */
+#define XPC_NOWAIT 1 /* no wait flag */

struct xpc_interface {
- void (*connect)(int);
- void (*disconnect)(int);
- enum xp_retval (*allocate)(short, int, u32, void **);
- enum xp_retval (*send)(short, int, void *);
- enum xp_retval (*send_notify)(short, int, void *,
- xpc_notify_func, void *);
- void (*received)(short, int, void *);
- enum xp_retval (*partid_to_nasids)(short, void *);
+ void (*connect) (int);
+ void (*disconnect) (int);
+ enum xp_retval (*allocate) (short, int, u32, void **);
+ enum xp_retval (*send) (short, int, void *);
+ enum xp_retval (*send_notify) (short, int, void *,
+ xpc_notify_func, void *);
+ void (*received) (short, int, void *);
+ enum xp_retval (*partid_to_nasids) (short, void *);
};

-
extern struct xpc_interface xpc_interface;

extern void xpc_set_interface(void (*)(int),
- void (*)(int),
- enum xp_retval (*)(short, int, u32, void **),
- enum xp_retval (*)(short, int, void *),
- enum xp_retval (*)(short, int, void *, xpc_notify_func,
- void *),
- void (*)(short, int, void *),
- enum xp_retval (*)(short, void *));
+ void (*)(int),
+ enum xp_retval (*)(short, int, u32, void **),
+ enum xp_retval (*)(short, int, void *),
+ enum xp_retval (*)(short, int, void *,
+ xpc_notify_func, void *),
+ void (*)(short, int, void *),
+ enum xp_retval (*)(short, void *));
extern void xpc_clear_interface(void);

-
extern enum xp_retval xpc_connect(int, xpc_channel_func, void *, u16,
- u16, u32, u32);
+ u16, u32, u32);
extern void xpc_disconnect(int);

static inline enum xp_retval
@@ -440,7 +422,7 @@ xpc_send(short partid, int ch_number, vo

static inline enum xp_retval
xpc_send_notify(short partid, int ch_number, void *payload,
- xpc_notify_func func, void *key)
+ xpc_notify_func func, void *key)
{
return xpc_interface.send_notify(partid, ch_number, payload, func, key);
}
@@ -460,31 +442,36 @@ xpc_partid_to_nasids(short partid, void
extern short xp_partition_id;
extern u8 xp_region_size;
extern unsigned long xp_rtc_cycles_per_second;
-extern enum xp_retval (*xp_remote_memcpy)(void *, const void *, size_t);
-extern enum xp_retval (*xp_register_remote_amos)(u64, size_t);
-extern enum xp_retval (*xp_unregister_remote_amos)(u64, size_t);
+extern enum xp_retval (*xp_remote_memcpy) (void *, const void *, size_t);
+extern enum xp_retval (*xp_register_remote_amos) (u64, size_t);
+extern enum xp_retval (*xp_unregister_remote_amos) (u64, size_t);
extern int xp_sizeof_nasid_mask;
extern int xp_sizeof_amo;
-extern u64 *(*xp_alloc_amos)(int);
-extern void (*xp_free_amos)(u64 *, int);
-extern enum xp_retval (*xp_set_amo)(u64 *, int, u64, int);
-extern enum xp_retval (*xp_set_amo_with_interrupt)(u64 *, int, u64, int, int,
+extern u64 *(*xp_alloc_amos) (int);
+extern void (*xp_free_amos) (u64 *, int);
+extern enum xp_retval (*xp_set_amo) (u64 *, int, u64, int);
+extern enum xp_retval (*xp_set_amo_with_interrupt) (u64 *, int, u64, int, int,
int, int);
-extern enum xp_retval (*xp_get_amo)(u64 *, int, u64 *);
-extern enum xp_retval (*xp_get_partition_rsvd_page_pa)(u64, u64 *, u64 *,
+extern enum xp_retval (*xp_get_amo) (u64 *, int, u64 *);
+extern enum xp_retval (*xp_get_partition_rsvd_page_pa) (u64, u64 *, u64 *,
size_t *);
-extern enum xp_retval (*xp_change_memprotect)(u64, size_t, int, u64 *);
-extern void (*xp_change_memprotect_shub_wars_1_1)(int);
-extern void (*xp_allow_IPI_ops)(void);
-extern void (*xp_disallow_IPI_ops)(void);
+extern enum xp_retval (*xp_change_memprotect) (u64, size_t, int, u64 *);
+extern void (*xp_change_memprotect_shub_wars_1_1) (int);
+extern void (*xp_allow_IPI_ops) (void);
+extern void (*xp_disallow_IPI_ops) (void);

-extern int (*xp_cpu_to_nasid)(int);
-extern int (*xp_node_to_nasid)(int);
+extern int (*xp_cpu_to_nasid) (int);
+extern int (*xp_node_to_nasid) (int);

extern u64 xp_nofault_PIOR_target;
extern int xp_nofault_PIOR(void *);
extern int xp_error_PIOR(void);

+extern struct device *xp;
+extern enum xp_retval xp_init_sn2(void);
+extern enum xp_retval xp_init_uv(void);
+extern void xp_exit_sn2(void);
+extern void xp_exit_uv(void);

static inline int
xp_partid_mask_words(int npartitions)
@@ -498,6 +485,4 @@ xp_nasid_mask_words(void)
return DIV_ROUND_UP(xp_sizeof_nasid_mask, BYTES_PER_WORD);
}

-
#endif /* _DRIVERS_MISC_XP_XP_H */
-
Index: linux-2.6/drivers/misc/xp/xp_main.c
===================================================================
--- linux-2.6.orig/drivers/misc/xp/xp_main.c 2008-03-21 13:30:52.030174502 -0500
+++ linux-2.6/drivers/misc/xp/xp_main.c 2008-03-24 19:31:37.154185684 -0500
@@ -6,7 +6,6 @@
* Copyright (c) 2004-2008 Silicon Graphics, Inc. All Rights Reserved.
*/

-
/*
* Cross Partition (XP) base.
*
@@ -15,7 +14,6 @@
*
*/

-
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
@@ -28,7 +26,7 @@ struct device_driver xp_dbg_name = {
};

struct device xp_dbg_subname = {
- .bus_id = {0}, /* set to "" */
+ .bus_id = {0}, /* set to "" */
.driver = &xp_dbg_name
};

@@ -43,66 +41,68 @@ short xp_partition_id;
u8 xp_region_size;
unsigned long xp_rtc_cycles_per_second;

-enum xp_retval (*xp_remote_memcpy)(void *dst, const void *src, size_t len);
+enum xp_retval (*xp_remote_memcpy) (void *dst, const void *src, size_t len);

-enum xp_retval (*xp_register_remote_amos)(u64 paddr, size_t len);
-enum xp_retval (*xp_unregister_remote_amos)(u64 paddr, size_t len);
+enum xp_retval (*xp_register_remote_amos) (u64 paddr, size_t len);
+enum xp_retval (*xp_unregister_remote_amos) (u64 paddr, size_t len);

int xp_sizeof_nasid_mask;
int xp_sizeof_amo;

-u64 *(*xp_alloc_amos)(int n_amos);
-void (*xp_free_amos)(u64 *amos_page, int n_amos);
+u64 *(*xp_alloc_amos) (int n_amos);
+void (*xp_free_amos) (u64 *amos_page, int n_amos);

-enum xp_retval (*xp_set_amo)(u64 *amo_va, int op, u64 operand, int remote);
-enum xp_retval (*xp_set_amo_with_interrupt)(u64 *amo_va, int op, u64 operand,
+enum xp_retval (*xp_set_amo) (u64 *amo_va, int op, u64 operand, int remote);
+enum xp_retval (*xp_set_amo_with_interrupt) (u64 *amo_va, int op, u64 operand,
int remote, int nasid,
int phys_cpuid, int vector);

-enum xp_retval (*xp_get_amo)(u64 *amo_va, int op, u64 *amo_value_addr);
+enum xp_retval (*xp_get_amo) (u64 *amo_va, int op, u64 *amo_value_addr);

-enum xp_retval (*xp_get_partition_rsvd_page_pa)(u64 buf, u64 *cookie,
+enum xp_retval (*xp_get_partition_rsvd_page_pa) (u64 buf, u64 *cookie,
u64 *paddr, size_t *len);

-enum xp_retval (*xp_change_memprotect)(u64 paddr, size_t len, int request,
+enum xp_retval (*xp_change_memprotect) (u64 paddr, size_t len, int request,
u64 *nasid_array);
-void (*xp_change_memprotect_shub_wars_1_1)(int request);
-void (*xp_allow_IPI_ops)(void);
-void (*xp_disallow_IPI_ops)(void);
-
-int (*xp_cpu_to_nasid)(int cpuid);
-int (*xp_node_to_nasid)(int nid);
+void (*xp_change_memprotect_shub_wars_1_1) (int request);
+void (*xp_allow_IPI_ops) (void);
+void (*xp_disallow_IPI_ops) (void);

+int (*xp_cpu_to_nasid) (int cpuid);
+int (*xp_node_to_nasid) (int nid);

/*
* Initialize the XPC interface to indicate that XPC isn't loaded.
*/
-static enum xp_retval xpc_notloaded(void) { return xpNotLoaded; }
+static enum xp_retval
+xpc_notloaded(void)
+{
+ return xpNotLoaded;
+}

struct xpc_interface xpc_interface = {
- (void (*)(int)) xpc_notloaded,
- (void (*)(int)) xpc_notloaded,
- (enum xp_retval (*)(short, int, u32, void **)) xpc_notloaded,
- (enum xp_retval (*)(short, int, void *)) xpc_notloaded,
- (enum xp_retval (*)(short, int, void *, xpc_notify_func, void *))
- xpc_notloaded,
- (void (*)(short, int, void *)) xpc_notloaded,
- (enum xp_retval (*)(short, void *)) xpc_notloaded
+ (void (*)(int))xpc_notloaded,
+ (void (*)(int))xpc_notloaded,
+ (enum xp_retval(*)(short, int, u32, void **))xpc_notloaded,
+ (enum xp_retval(*)(short, int, void *))xpc_notloaded,
+ (enum xp_retval(*)(short, int, void *, xpc_notify_func, void *))
+ xpc_notloaded,
+ (void (*)(short, int, void *))xpc_notloaded,
+ (enum xp_retval(*)(short, void *))xpc_notloaded
};

-
/*
* XPC calls this when it (the XPC module) has been loaded.
*/
void
-xpc_set_interface(void (*connect)(int),
- void (*disconnect)(int),
- enum xp_retval (*allocate)(short, int, u32, void **),
- enum xp_retval (*send)(short, int, void *),
- enum xp_retval (*send_notify)(short, int, void *,
- xpc_notify_func, void *),
- void (*received)(short, int, void *),
- enum xp_retval (*partid_to_nasids)(short, void *))
+xpc_set_interface(void (*connect) (int),
+ void (*disconnect) (int),
+ enum xp_retval (*allocate) (short, int, u32, void **),
+ enum xp_retval (*send) (short, int, void *),
+ enum xp_retval (*send_notify) (short, int, void *,
+ xpc_notify_func, void *),
+ void (*received) (short, int, void *),
+ enum xp_retval (*partid_to_nasids) (short, void *))
{
xpc_interface.connect = connect;
xpc_interface.disconnect = disconnect;
@@ -113,35 +113,33 @@ xpc_set_interface(void (*connect)(int),
xpc_interface.partid_to_nasids = partid_to_nasids;
}

-
/*
* XPC calls this when it (the XPC module) is being unloaded.
*/
void
xpc_clear_interface(void)
{
- xpc_interface.connect = (void (*)(int)) xpc_notloaded;
- xpc_interface.disconnect = (void (*)(int)) xpc_notloaded;
- xpc_interface.allocate = (enum xp_retval (*)(short, int, u32,
- void **)) xpc_notloaded;
- xpc_interface.send = (enum xp_retval (*)(short, int, void *))
- xpc_notloaded;
- xpc_interface.send_notify = (enum xp_retval (*)(short, int, void *,
- xpc_notify_func, void *)) xpc_notloaded;
+ xpc_interface.connect = (void (*)(int))xpc_notloaded;
+ xpc_interface.disconnect = (void (*)(int))xpc_notloaded;
+ xpc_interface.allocate = (enum xp_retval(*)(short, int, u32,
+ void **))xpc_notloaded;
+ xpc_interface.send = (enum xp_retval(*)(short, int, void *))
+ xpc_notloaded;
+ xpc_interface.send_notify = (enum xp_retval(*)(short, int, void *,
+ xpc_notify_func,
+ void *))xpc_notloaded;
xpc_interface.received = (void (*)(short, int, void *))
- xpc_notloaded;
- xpc_interface.partid_to_nasids = (enum xp_retval (*)(short, void *))
- xpc_notloaded;
+ xpc_notloaded;
+ xpc_interface.partid_to_nasids = (enum xp_retval(*)(short, void *))
+ xpc_notloaded;
}

-
/*
* xpc_registrations[] keeps track of xpc_connect()'s done by the kernel-level
* users of XPC.
*/
struct xpc_registration xpc_registrations[XPC_NCHANNELS];

-
/*
* Register for automatic establishment of a channel connection whenever
* a partition comes up.
@@ -168,11 +166,10 @@ struct xpc_registration xpc_registration
*/
enum xp_retval
xpc_connect(int ch_number, xpc_channel_func func, void *key, u16 payload_size,
- u16 nentries, u32 assigned_limit, u32 idle_limit)
+ u16 nentries, u32 assigned_limit, u32 idle_limit)
{
struct xpc_registration *registration;

-
DBUG_ON(ch_number < 0 || ch_number >= XPC_NCHANNELS);
DBUG_ON(payload_size == 0 || nentries == 0);
DBUG_ON(func == NULL);
@@ -205,7 +202,6 @@ xpc_connect(int ch_number, xpc_channel_f
return xpSuccess;
}

-
/*
* Remove the registration for automatic connection of the specified channel
* when a partition comes up.
@@ -224,7 +220,6 @@ xpc_disconnect(int ch_number)
{
struct xpc_registration *registration;

-
DBUG_ON(ch_number < 0 || ch_number >= XPC_NCHANNELS);

registration = &xpc_registrations[ch_number];
@@ -284,6 +279,7 @@ xp_init(void)

return 0;
}
+
module_init(xp_init);

extern void xp_exit_sn2(void);
@@ -297,8 +293,8 @@ xp_exit(void)
else if (is_uv())
xp_exit_uv();
}
-module_exit(xp_exit);

+module_exit(xp_exit);

MODULE_AUTHOR("Silicon Graphics, Inc.");
MODULE_DESCRIPTION("Cross Partition (XP) base");
@@ -330,4 +326,3 @@ EXPORT_SYMBOL(xpc_clear_interface);
EXPORT_SYMBOL(xpc_set_interface);
EXPORT_SYMBOL(xpc_connect);
EXPORT_SYMBOL(xpc_disconnect);
-
Index: linux-2.6/drivers/misc/xp/xp_sn2.c
===================================================================
--- linux-2.6.orig/drivers/misc/xp/xp_sn2.c 2008-03-21 13:30:52.030174502 -0500
+++ linux-2.6/drivers/misc/xp/xp_sn2.c 2008-03-24 19:31:37.154185684 -0500
@@ -67,7 +67,7 @@ xp_unregister_nofault_code_sn2(void)

/* unregister the PIO read nofault code region */
(void)sn_register_nofault_code(func_addr, err_func_addr,
- err_func_addr, 1, 0);
+ err_func_addr, 1, 0);
}

/*
@@ -155,15 +155,14 @@ xp_free_amos_sn2(u64 *amos_page, int n_a
{
int n_pages = DIV_ROUND_UP(n_amos * xp_sizeof_amo, PAGE_SIZE);

- uncached_free_page(__IA64_UNCACHED_OFFSET | TO_PHYS((u64) amos_page),
+ uncached_free_page(__IA64_UNCACHED_OFFSET | TO_PHYS((u64)amos_page),
n_pages);
}

-
static enum xp_retval
xp_set_amo_sn2(u64 *amo_va, int op, u64 operand, int remote)
{
- unsigned long irq_flags = irq_flags; /* eliminate compiler warning */
+ unsigned long irq_flags = irq_flags; /* eliminate compiler warning */
int ret = xpSuccess;
/* >>> eliminate remote arg and xp_nofault_PIOR() call */

@@ -188,7 +187,8 @@ xp_set_amo_sn2(u64 *amo_va, int op, u64
* it until the heartbeat times out.
*/
if (xp_nofault_PIOR((u64 *)GLOBAL_MMR_ADDR(NASID_GET(amo_va),
- xp_nofault_PIOR_target)) != 0)
+ xp_nofault_PIOR_target))
+ != 0)
ret = xpPioReadError;

local_irq_restore(irq_flags);
@@ -201,7 +201,7 @@ static enum xp_retval
xp_set_amo_with_interrupt_sn2(u64 *amo_va, int op, u64 operand, int remote,
int nasid, int phys_cpuid, int vector)
{
- unsigned long irq_flags = irq_flags; /* eliminate compiler warning */
+ unsigned long irq_flags = irq_flags; /* eliminate compiler warning */
int ret = xpSuccess;

if (op == XP_AMO_AND)
@@ -226,7 +226,8 @@ xp_set_amo_with_interrupt_sn2(u64 *amo_v
* it until the heartbeat times out.
*/
if (xp_nofault_PIOR((u64 *)GLOBAL_MMR_ADDR(NASID_GET(amo_va),
- xp_nofault_PIOR_target)) != 0)
+ xp_nofault_PIOR_target))
+ != 0)
ret = xpPioReadError;

local_irq_restore(irq_flags);
@@ -321,22 +322,28 @@ xp_change_memprotect_shub_wars_1_1_sn2(i
nasid = cnodeid_to_nasid(node);
/* save current protection values */
xpc_prot_vec[node] =
- (u64)HUB_L((u64 *)GLOBAL_MMR_ADDR(nasid,
- SH1_MD_DQLP_MMR_DIR_PRIVEC0));
+ (u64)HUB_L((u64 *)GLOBAL_MMR_ADDR(nasid,
+ SH1_MD_DQLP_MMR_DIR_PRIVEC0));
/* open up everything */
HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid,
- SH1_MD_DQLP_MMR_DIR_PRIVEC0), -1UL);
- HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid,
- SH1_MD_DQRP_MMR_DIR_PRIVEC0), -1UL);
+ SH1_MD_DQLP_MMR_DIR_PRIVEC0),
+ -1UL);
+ HUB_S((u64 *)
+ GLOBAL_MMR_ADDR(nasid,
+ SH1_MD_DQRP_MMR_DIR_PRIVEC0),
+ -1UL);
}
} else if (request == XP_MEMPROT_DISALLOW_ALL) {
for_each_online_node(node) {
nasid = cnodeid_to_nasid(node);
/* restore original protection values */
HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid,
- SH1_MD_DQLP_MMR_DIR_PRIVEC0), xpc_prot_vec[node]);
- HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid,
- SH1_MD_DQRP_MMR_DIR_PRIVEC0), xpc_prot_vec[node]);
+ SH1_MD_DQLP_MMR_DIR_PRIVEC0),
+ xpc_prot_vec[node]);
+ HUB_S((u64 *)
+ GLOBAL_MMR_ADDR(nasid,
+ SH1_MD_DQRP_MMR_DIR_PRIVEC0),
+ xpc_prot_vec[node]);
}
} else
BUG();
@@ -361,13 +368,13 @@ xp_allow_IPI_ops_sn2(void)
/* >>> The following should get moved into SAL. */
if (is_shub2()) {
xpc_sh2_IPI_access0 =
- (u64)HUB_L((u64 *)LOCAL_MMR_ADDR(SH2_IPI_ACCESS0));
+ (u64)HUB_L((u64 *)LOCAL_MMR_ADDR(SH2_IPI_ACCESS0));
xpc_sh2_IPI_access1 =
- (u64)HUB_L((u64 *)LOCAL_MMR_ADDR(SH2_IPI_ACCESS1));
+ (u64)HUB_L((u64 *)LOCAL_MMR_ADDR(SH2_IPI_ACCESS1));
xpc_sh2_IPI_access2 =
- (u64)HUB_L((u64 *)LOCAL_MMR_ADDR(SH2_IPI_ACCESS2));
+ (u64)HUB_L((u64 *)LOCAL_MMR_ADDR(SH2_IPI_ACCESS2));
xpc_sh2_IPI_access3 =
- (u64)HUB_L((u64 *)LOCAL_MMR_ADDR(SH2_IPI_ACCESS3));
+ (u64)HUB_L((u64 *)LOCAL_MMR_ADDR(SH2_IPI_ACCESS3));

for_each_online_node(node) {
nasid = cnodeid_to_nasid(node);
@@ -382,7 +389,7 @@ xp_allow_IPI_ops_sn2(void)
}
} else {
xpc_sh1_IPI_access =
- (u64)HUB_L((u64 *)LOCAL_MMR_ADDR(SH1_IPI_ACCESS));
+ (u64)HUB_L((u64 *)LOCAL_MMR_ADDR(SH1_IPI_ACCESS));

for_each_online_node(node) {
nasid = cnodeid_to_nasid(node);
@@ -455,7 +462,7 @@ xp_init_sn2(void)
* reflect its existence.
*/
BUG_ON(offsetof(AMO_t, variable) != 0);
- BUG_ON(sizeof(((AMO_t *)NULL)->variable) != sizeof(u64));
+ BUG_ON(sizeof(((AMO_t *) NULL)->variable) != sizeof(u64));
xp_sizeof_amo = sizeof(AMO_t);
xp_alloc_amos = xp_alloc_amos_sn2;
xp_free_amos = xp_free_amos_sn2;
@@ -467,7 +474,7 @@ xp_init_sn2(void)

xp_change_memprotect = xp_change_memprotect_sn2;
xp_change_memprotect_shub_wars_1_1 =
- xp_change_memprotect_shub_wars_1_1_sn2;
+ xp_change_memprotect_shub_wars_1_1_sn2;
xp_allow_IPI_ops = xp_allow_IPI_ops_sn2;
xp_disallow_IPI_ops = xp_disallow_IPI_ops_sn2;

@@ -484,4 +491,3 @@ xp_exit_sn2(void)

xp_unregister_nofault_code_sn2();
}
-
Index: linux-2.6/drivers/misc/xp/xp_uv.c
===================================================================
--- linux-2.6.orig/drivers/misc/xp/xp_uv.c 2008-03-21 13:30:52.030174502 -0500
+++ linux-2.6/drivers/misc/xp/xp_uv.c 2008-03-24 19:31:37.154185684 -0500
@@ -154,8 +154,8 @@ xp_init_uv(void)
{
BUG_ON(!is_uv());

- xp_partition_id = 0; /* >>> not correct value */
- xp_region_size = 0; /* >>> not correct value */
+ xp_partition_id = 0; /* >>> not correct value */
+ xp_region_size = 0; /* >>> not correct value */
xp_rtc_cycles_per_second = 0; /* >>> not correct value */

xp_remote_memcpy = xp_remote_memcpy_uv;
@@ -174,7 +174,7 @@ xp_init_uv(void)

xp_change_memprotect = xp_change_memprotect_uv;
xp_change_memprotect_shub_wars_1_1 =
- xp_change_memprotect_shub_wars_1_1_uv;
+ xp_change_memprotect_shub_wars_1_1_uv;
xp_allow_IPI_ops = xp_allow_IPI_ops_uv;
xp_disallow_IPI_ops = xp_disallow_IPI_ops_uv;

@@ -191,4 +191,3 @@ xp_exit_uv(void)

xp_unregister_nofault_code_uv();
}
-
Index: linux-2.6/drivers/misc/xp/xpc.h
===================================================================
--- linux-2.6.orig/drivers/misc/xp/xpc.h 2008-03-21 13:30:52.030174502 -0500
+++ linux-2.6/drivers/misc/xp/xpc.h 2008-03-24 19:31:37.154185684 -0500
@@ -6,7 +6,6 @@
* Copyright (c) 2004-2008 Silicon Graphics, Inc. All Rights Reserved.
*/

-
/*
* Cross Partition Communication (XPC) structures and macros.
*/
@@ -14,7 +13,6 @@
#ifndef _DRIVERS_MISC_XP_XPC_H
#define _DRIVERS_MISC_XP_XPC_H

-
#include <linux/interrupt.h>
#include <linux/sysctl.h>
#include <linux/device.h>
@@ -32,7 +30,6 @@
#endif
#include "xp.h"

-
/*
* XPC Version numbers consist of a major and minor number. XPC can always
* talk to versions with same major #, and never talk to versions with a
@@ -42,7 +39,6 @@
#define XPC_VERSION_MAJOR(_v) ((_v) >> 4)
#define XPC_VERSION_MINOR(_v) ((_v) & 0xf)

-
/*
* The next macros define word or bit representations for given
* C-brick nasid in either the SAL provided bit array representing
@@ -66,7 +62,6 @@
/* define the process name of the discovery thread */
#define XPC_DISCOVERY_THREAD_NAME "xpc_discovery"

-
/*
* the reserved page
*
@@ -120,7 +115,7 @@ struct xpc_rsvd_page {
u64 SAL_nasids_size; /* SAL: size of each nasid mask in bytes */
};

-#define XPC_RP_VERSION _XPC_VERSION(2,0) /* version 2.0 of the reserved page */
+#define XPC_RP_VERSION _XPC_VERSION(2,0) /* version 2.0 of the reserved page */

#define XPC_SUPPORTS_RP_STAMP(_version) \
(_version >= _XPC_VERSION(1,1))
@@ -137,14 +132,12 @@ xpc_compare_stamps(struct timespec *stam
{
int ret;

-
if ((ret = stamp1->tv_sec - stamp2->tv_sec) == 0) {
ret = stamp1->tv_nsec - stamp2->tv_nsec;
}
return ret;
}

-
/*
* Define the structures by which XPC variables can be exported to other
* partitions. (There are two: struct xpc_vars and struct xpc_vars_part)
@@ -173,12 +166,11 @@ struct xpc_vars {
u64 heartbeating_to_mask[BITS_TO_LONGS(XP_MAX_NPARTITIONS)];
};

-#define XPC_V_VERSION _XPC_VERSION(4,0) /* version 4.0 of the cross vars */
+#define XPC_V_VERSION _XPC_VERSION(4,0) /* version 4.0 of the cross vars */

#define XPC_SUPPORTS_DISENGAGE_REQUEST(_version) \
(_version >= _XPC_VERSION(3,1))

-
static inline int
xpc_hb_allowed(short partid, struct xpc_vars *vars)
{
@@ -214,7 +206,6 @@ xpc_disallow_all_hbs(struct xpc_vars *va
vars->heartbeating_to_mask[i] = 0;
}

-
/*
* The AMOs page(s) consists of a number of AMO variables which are divided into
* four groups, The first group consists of one AMO per partition, each of which
@@ -254,7 +245,7 @@ static inline int
xpc_disengage_request_amos(int npartitions)
{
return xpc_engaged_partitions_amos(npartitions) +
- xp_partid_mask_words(npartitions);
+ xp_partid_mask_words(npartitions);
}

/* get total number of AMOs */
@@ -262,10 +253,9 @@ static inline int
xpc_number_of_amos(int npartitions)
{
return xpc_disengage_request_amos(npartitions) +
- xp_partid_mask_words(npartitions);
+ xp_partid_mask_words(npartitions);
}

-
/*
* The following structure describes the per partition specific variables.
*
@@ -300,9 +290,8 @@ struct xpc_vars_part {
* MAGIC2 indicates that this partition has pulled the remote partititions
* per partition variables that pertain to this partition.
*/
-#define XPC_VP_MAGIC1 0x0053524156435058L /* 'XPCVARS\0'L (little endian) */
-#define XPC_VP_MAGIC2 0x0073726176435058L /* 'XPCvars\0'L (little endian) */
-
+#define XPC_VP_MAGIC1 0x0053524156435058L /* 'XPCVARS\0'L (little endian) */
+#define XPC_VP_MAGIC2 0x0073726176435058L /* 'XPCvars\0'L (little endian) */

/* the reserved page sizes and offsets */

@@ -316,7 +305,6 @@ struct xpc_vars_part {
xp_nasid_mask_words())
#define XPC_RP_VARS_PART(_rp) (struct xpc_vars_part *)((u8 *)XPC_RP_VARS(_rp) + XPC_RP_VARS_SIZE)

-
/*
* Functions registered by add_timer() or called by kernel_thread() only
* allow for a single 64-bit argument. The following macros can be used to
@@ -330,8 +318,6 @@ struct xpc_vars_part {
#define XPC_UNPACK_ARG1(_args) (((u64) _args) & 0xffffffff)
#define XPC_UNPACK_ARG2(_args) ((((u64) _args) >> 32) & 0xffffffff)

-
-
/*
* Define a Get/Put value pair (pointers) used with a message queue.
*/
@@ -343,8 +329,6 @@ struct xpc_gp {
#define XPC_GP_SIZE \
L1_CACHE_ALIGN(sizeof(struct xpc_gp) * XPC_NCHANNELS)

-
-
/*
* Define a structure that contains arguments associated with opening and
* closing a channel.
@@ -360,20 +344,15 @@ struct xpc_openclose_args {
#define XPC_OPENCLOSE_ARGS_SIZE \
L1_CACHE_ALIGN(sizeof(struct xpc_openclose_args) * XPC_NCHANNELS)

-
-
/* struct xpc_msg flags */

#define XPC_M_DONE 0x01 /* msg has been received/consumed */
#define XPC_M_READY 0x02 /* msg is ready to be sent */
#define XPC_M_INTERRUPT 0x04 /* send interrupt when msg consumed */

-
#define XPC_MSG_ADDRESS(_payload) \
((struct xpc_msg *)((u8 *)(_payload) - XPC_MSG_PAYLOAD_OFFSET))

-
-
/*
* Defines notify entry.
*
@@ -381,19 +360,17 @@ struct xpc_openclose_args {
* and consumed by the intended recipient.
*/
struct xpc_notify {
- volatile u8 type; /* type of notification */
+ volatile u8 type; /* type of notification */

/* the following two fields are only used if type == XPC_N_CALL */
- xpc_notify_func func; /* user's notify function */
- void *key; /* pointer to user's key */
+ xpc_notify_func func; /* user's notify function */
+ void *key; /* pointer to user's key */
};

/* struct xpc_notify type of notification */

#define XPC_N_CALL 0x01 /* notify function provided by user */

-
-
/*
* Define the structure that manages all the stuff required by a channel. In
* particular, they are used to manage the messages sent across the channel.
@@ -473,48 +450,48 @@ struct xpc_notify {
* messages.
*/
struct xpc_channel {
- short partid; /* ID of remote partition connected */
- spinlock_t lock; /* lock for updating this structure */
- u32 flags; /* general flags */
-
- enum xp_retval reason; /* reason why channel is disconnect'g */
- int reason_line; /* line# disconnect initiated from */
-
- u16 number; /* channel # */
-
- u16 msg_size; /* sizeof each msg entry */
- u16 local_nentries; /* #of msg entries in local msg queue */
- u16 remote_nentries; /* #of msg entries in remote msg queue*/
+ short partid; /* ID of remote partition connected */
+ spinlock_t lock; /* lock for updating this structure */
+ u32 flags; /* general flags */
+
+ enum xp_retval reason; /* reason why channel is disconnect'g */
+ int reason_line; /* line# disconnect initiated from */
+
+ u16 number; /* channel # */
+
+ u16 msg_size; /* sizeof each msg entry */
+ u16 local_nentries; /* #of msg entries in local msg queue */
+ u16 remote_nentries; /* #of msg entries in remote msg queue */

void *local_msgqueue_base; /* base address of kmalloc'd space */
struct xpc_msg *local_msgqueue; /* local message queue */
void *remote_msgqueue_base; /* base address of kmalloc'd space */
- struct xpc_msg *remote_msgqueue;/* cached copy of remote partition's */
- /* local message queue */
- u64 remote_msgqueue_pa; /* phys addr of remote partition's */
- /* local message queue */
+ struct xpc_msg *remote_msgqueue; /* cached copy of remote partition's */
+ /* local message queue */
+ u64 remote_msgqueue_pa; /* phys addr of remote partition's */
+ /* local message queue */

- atomic_t references; /* #of external references to queues */
+ atomic_t references; /* #of external references to queues */

- atomic_t n_on_msg_allocate_wq; /* #on msg allocation wait queue */
- wait_queue_head_t msg_allocate_wq; /* msg allocation wait queue */
+ atomic_t n_on_msg_allocate_wq; /* #on msg allocation wait queue */
+ wait_queue_head_t msg_allocate_wq; /* msg allocation wait queue */

- u8 delayed_IPI_flags; /* IPI flags received, but delayed */
- /* action until channel disconnected */
+ u8 delayed_IPI_flags; /* IPI flags received, but delayed */
+ /* action until channel disconnected */

/* queue of msg senders who want to be notified when msg received */

- atomic_t n_to_notify; /* #of msg senders to notify */
- struct xpc_notify *notify_queue;/* notify queue for messages sent */
+ atomic_t n_to_notify; /* #of msg senders to notify */
+ struct xpc_notify *notify_queue; /* notify queue for messages sent */

- xpc_channel_func func; /* user's channel function */
- void *key; /* pointer to user's key */
+ xpc_channel_func func; /* user's channel function */
+ void *key; /* pointer to user's key */

struct mutex msg_to_pull_mutex; /* next msg to pull serialization */
- struct completion wdisconnect_wait; /* wait for channel disconnect */
+ struct completion wdisconnect_wait; /* wait for channel disconnect */

- struct xpc_openclose_args *local_openclose_args; /* args passed on */
- /* opening or closing of channel */
+ struct xpc_openclose_args *local_openclose_args; /* args passed on */
+ /* opening or closing of channel */

/* various flavors of local and remote Get/Put values */

@@ -522,13 +499,13 @@ struct xpc_channel {
struct xpc_gp remote_GP; /* remote Get/Put values */
struct xpc_gp w_local_GP; /* working local Get/Put values */
struct xpc_gp w_remote_GP; /* working remote Get/Put values */
- s64 next_msg_to_pull; /* Put value of next msg to pull */
+ s64 next_msg_to_pull; /* Put value of next msg to pull */

/* kthread management related fields */

atomic_t kthreads_assigned; /* #of kthreads assigned to channel */
- u32 kthreads_assigned_limit; /* limit on #of kthreads assigned */
- atomic_t kthreads_idle; /* #of kthreads idle waiting for work */
+ u32 kthreads_assigned_limit; /* limit on #of kthreads assigned */
+ atomic_t kthreads_idle; /* #of kthreads idle waiting for work */
u32 kthreads_idle_limit; /* limit on #of kthreads idle */
atomic_t kthreads_active; /* #of kthreads actively working */

@@ -536,37 +513,34 @@ struct xpc_channel {

} ____cacheline_aligned;

-
/* struct xpc_channel flags */

-#define XPC_C_WASCONNECTED 0x00000001 /* channel was connected */
+#define XPC_C_WASCONNECTED 0x00000001 /* channel was connected */

-#define XPC_C_ROPENREPLY 0x00000002 /* remote open channel reply */
-#define XPC_C_OPENREPLY 0x00000004 /* local open channel reply */
-#define XPC_C_ROPENREQUEST 0x00000008 /* remote open channel request */
-#define XPC_C_OPENREQUEST 0x00000010 /* local open channel request */
+#define XPC_C_ROPENREPLY 0x00000002 /* remote open channel reply */
+#define XPC_C_OPENREPLY 0x00000004 /* local open channel reply */
+#define XPC_C_ROPENREQUEST 0x00000008 /* remote open channel request */
+#define XPC_C_OPENREQUEST 0x00000010 /* local open channel request */

-#define XPC_C_SETUP 0x00000020 /* channel's msgqueues are alloc'd */
-#define XPC_C_CONNECTEDCALLOUT 0x00000040 /* connected callout initiated */
+#define XPC_C_SETUP 0x00000020 /* channel's msgqueues are alloc'd */
+#define XPC_C_CONNECTEDCALLOUT 0x00000040 /* connected callout initiated */
#define XPC_C_CONNECTEDCALLOUT_MADE \
- 0x00000080 /* connected callout completed */
-#define XPC_C_CONNECTED 0x00000100 /* local channel is connected */
-#define XPC_C_CONNECTING 0x00000200 /* channel is being connected */
-
-#define XPC_C_RCLOSEREPLY 0x00000400 /* remote close channel reply */
-#define XPC_C_CLOSEREPLY 0x00000800 /* local close channel reply */
-#define XPC_C_RCLOSEREQUEST 0x00001000 /* remote close channel request */
-#define XPC_C_CLOSEREQUEST 0x00002000 /* local close channel request */
+ 0x00000080 /* connected callout completed */
+#define XPC_C_CONNECTED 0x00000100 /* local channel is connected */
+#define XPC_C_CONNECTING 0x00000200 /* channel is being connected */
+
+#define XPC_C_RCLOSEREPLY 0x00000400 /* remote close channel reply */
+#define XPC_C_CLOSEREPLY 0x00000800 /* local close channel reply */
+#define XPC_C_RCLOSEREQUEST 0x00001000 /* remote close channel request */
+#define XPC_C_CLOSEREQUEST 0x00002000 /* local close channel request */

-#define XPC_C_DISCONNECTED 0x00004000 /* channel is disconnected */
-#define XPC_C_DISCONNECTING 0x00008000 /* channel is being disconnected */
+#define XPC_C_DISCONNECTED 0x00004000 /* channel is disconnected */
+#define XPC_C_DISCONNECTING 0x00008000 /* channel is being disconnected */
#define XPC_C_DISCONNECTINGCALLOUT \
- 0x00010000 /* disconnecting callout initiated */
+ 0x00010000 /* disconnecting callout initiated */
#define XPC_C_DISCONNECTINGCALLOUT_MADE \
- 0x00020000 /* disconnecting callout completed */
-#define XPC_C_WDISCONNECT 0x00040000 /* waiting for channel disconnect */
-
-
+ 0x00020000 /* disconnecting callout completed */
+#define XPC_C_WDISCONNECT 0x00040000 /* waiting for channel disconnect */

/*
* Manages channels on a partition basis. There is one of these structures
@@ -577,36 +551,34 @@ struct xpc_partition {

/* XPC HB infrastructure */

- u8 remote_rp_version; /* version# of partition's rsvd pg */
+ u8 remote_rp_version; /* version# of partition's rsvd pg */
short remote_npartitions; /* value of XPC_NPARTITIONS */
- u32 flags; /* general flags */
- struct timespec remote_rp_stamp;/* time when rsvd pg was initialized */
- u64 remote_rp_pa; /* phys addr of partition's rsvd pg */
- u64 remote_vars_pa; /* phys addr of partition's vars */
+ u32 flags; /* general flags */
+ struct timespec remote_rp_stamp; /* time when rsvd pg was initialized */
+ u64 remote_rp_pa; /* phys addr of partition's rsvd pg */
+ u64 remote_vars_pa; /* phys addr of partition's vars */
u64 remote_vars_part_pa; /* phys addr of partition's vars part */
- u64 last_heartbeat; /* HB at last read */
+ u64 last_heartbeat; /* HB at last read */
u64 remote_amos_page_pa; /* phys addr of partition's amos page */
- int remote_act_nasid; /* active part's act/deact nasid */
+ int remote_act_nasid; /* active part's act/deact nasid */
int remote_act_phys_cpuid; /* active part's act/deact phys cpuid */
- u32 act_IRQ_rcvd; /* IRQs since activation */
- spinlock_t lock; /* protect updating of act_state and */
- /* the general flags */
- u8 act_state; /* from XPC HB viewpoint */
- u8 remote_vars_version; /* version# of partition's vars */
- enum xp_retval reason; /* reason partition is deactivating */
- int reason_line; /* line# deactivation initiated from */
- int reactivate_nasid; /* nasid in partition to reactivate */
+ u32 act_IRQ_rcvd; /* IRQs since activation */
+ spinlock_t lock; /* protect updating of act_state and */
+ /* the general flags */
+ u8 act_state; /* from XPC HB viewpoint */
+ u8 remote_vars_version; /* version# of partition's vars */
+ enum xp_retval reason; /* reason partition is deactivating */
+ int reason_line; /* line# deactivation initiated from */
+ int reactivate_nasid; /* nasid in partition to reactivate */

- unsigned long disengage_request_timeout; /* timeout in jiffies */
+ unsigned long disengage_request_timeout; /* timeout in jiffies */
struct timer_list disengage_request_timer;

-
/* XPC infrastructure referencing and teardown control */

volatile u8 setup_state; /* infrastructure setup state */
wait_queue_head_t teardown_wq; /* kthread waiting to teardown infra */
- atomic_t references; /* #of references to infrastructure */
-
+ atomic_t references; /* #of references to infrastructure */

/*
* NONE OF THE PRECEDING FIELDS OF THIS STRUCTURE WILL BE CLEARED WHEN
@@ -615,55 +587,51 @@ struct xpc_partition {
* 'nchannels' FIELD MUST BE THE FIRST OF THE FIELDS TO BE CLEARED.)
*/

-
- u8 nchannels; /* #of defined channels supported */
- atomic_t nchannels_active; /* #of channels that are not DISCONNECTED */
- atomic_t nchannels_engaged;/* #of channels engaged with remote part */
- struct xpc_channel *channels;/* array of channel structures */
-
- void *local_GPs_base; /* base address of kmalloc'd space */
- struct xpc_gp *local_GPs; /* local Get/Put values */
- void *remote_GPs_base; /* base address of kmalloc'd space */
- struct xpc_gp *remote_GPs;/* copy of remote partition's local Get/Put */
- /* values */
- u64 remote_GPs_pa; /* phys address of remote partition's local */
- /* Get/Put values */
-
+ u8 nchannels; /* #of defined channels supported */
+ atomic_t nchannels_active; /* #of channels that are not DISCONNECTED */
+ atomic_t nchannels_engaged; /* #of channels engaged with remote part */
+ struct xpc_channel *channels; /* array of channel structures */
+
+ void *local_GPs_base; /* base address of kmalloc'd space */
+ struct xpc_gp *local_GPs; /* local Get/Put values */
+ void *remote_GPs_base; /* base address of kmalloc'd space */
+ struct xpc_gp *remote_GPs; /* copy of remote partition's local Get/Put */
+ /* values */
+ u64 remote_GPs_pa; /* phys address of remote partition's local */
+ /* Get/Put values */

/* fields used to pass args when opening or closing a channel */

- void *local_openclose_args_base; /* base address of kmalloc'd space */
- struct xpc_openclose_args *local_openclose_args; /* local's args */
- void *remote_openclose_args_base; /* base address of kmalloc'd space */
- struct xpc_openclose_args *remote_openclose_args; /* copy of remote's */
- /* args */
- u64 remote_openclose_args_pa; /* phys addr of remote's args */
-
+ void *local_openclose_args_base; /* base address of kmalloc'd space */
+ struct xpc_openclose_args *local_openclose_args; /* local's args */
+ void *remote_openclose_args_base; /* base address of kmalloc'd space */
+ struct xpc_openclose_args *remote_openclose_args; /* copy of remote's */
+ /* args */
+ u64 remote_openclose_args_pa; /* phys addr of remote's args */

/* IPI sending, receiving and handling related fields */

- int remote_IPI_nasid; /* nasid of where to send IPIs */
- int remote_IPI_phys_cpuid; /* phys CPU ID of where to send IPIs */
- u64 *remote_IPI_amo_va; /* address of remote IPI AMO variable */
-
- u64 *local_IPI_amo_va; /* address of IPI AMO variable */
- u64 local_IPI_amo; /* IPI amo flags yet to be handled */
- char IPI_owner[8]; /* IPI owner's name */
- struct timer_list dropped_IPI_timer; /* dropped IPI timer */
-
- spinlock_t IPI_lock; /* IPI handler lock */
+ int remote_IPI_nasid; /* nasid of where to send IPIs */
+ int remote_IPI_phys_cpuid; /* phys CPU ID of where to send IPIs */
+ u64 *remote_IPI_amo_va; /* address of remote IPI AMO variable */
+
+ u64 *local_IPI_amo_va; /* address of IPI AMO variable */
+ u64 local_IPI_amo; /* IPI amo flags yet to be handled */
+ char IPI_owner[8]; /* IPI owner's name */
+ struct timer_list dropped_IPI_timer; /* dropped IPI timer */

+ spinlock_t IPI_lock; /* IPI handler lock */

/* channel manager related fields */

atomic_t channel_mgr_requests; /* #of requests to activate chan mgr */
- wait_queue_head_t channel_mgr_wq; /* channel mgr's wait queue */
+ wait_queue_head_t channel_mgr_wq; /* channel mgr's wait queue */

} ____cacheline_aligned;

/* struct xpc_partition flags */

-#define XPC_P_RAMOSREGISTERED 0x00000001 /* remote AMOs were registered */
+#define XPC_P_RAMOSREGISTERED 0x00000001 /* remote AMOs were registered */

/* struct xpc_partition act_state values (for XPC HB) */

@@ -673,11 +641,9 @@ struct xpc_partition {
#define XPC_P_AS_ACTIVE 0x03 /* xpc_partition_up() was called */
#define XPC_P_AS_DEACTIVATING 0x04 /* partition deactivation initiated */

-
#define XPC_DEACTIVATE_PARTITION(_p, _reason) \
xpc_deactivate_partition(__LINE__, (_p), (_reason))

-
/* struct xpc_partition setup_state values */

#define XPC_P_SS_UNSET 0x00 /* infrastructure was never setup */
@@ -685,8 +651,6 @@ struct xpc_partition {
#define XPC_P_SS_WTEARDOWN 0x02 /* waiting to teardown infrastructure */
#define XPC_P_SS_TORNDOWN 0x03 /* infrastructure is torndown */

-
-
/*
* struct xpc_partition IPI_timer #of seconds to wait before checking for
* dropped IPIs. These occur whenever an IPI amo write doesn't complete until
@@ -694,22 +658,17 @@ struct xpc_partition {
*/
#define XPC_DROPPED_IPI_WAIT_INTERVAL (0.25 * HZ)

-
/* number of seconds to wait for other partitions to disengage */
#define XPC_DISENGAGE_REQUEST_DEFAULT_TIMELIMIT 90

/* interval in seconds to print 'waiting disengagement' messages */
#define XPC_DISENGAGE_PRINTMSG_INTERVAL 10

-
#define XPC_PARTID(_p) ((short) ((_p) - &xpc_partitions[0]))

-
-
/* found in xp_main.c */
extern struct xpc_registration xpc_registrations[];

-
/* found in xpc_main.c */
extern struct device *xpc_part;
extern struct device *xpc_chan;
@@ -722,7 +681,6 @@ extern void xpc_activate_kthreads(struct
extern void xpc_create_kthreads(struct xpc_channel *, int, int);
extern void xpc_disconnect_wait(int);

-
/* found in xpc_partition.c */
extern int xpc_exiting;
extern struct xpc_vars *xpc_vars;
@@ -737,7 +695,7 @@ extern int xpc_identify_act_IRQ_sender(v
extern int xpc_partition_disengaged(struct xpc_partition *);
extern enum xp_retval xpc_mark_partition_active(struct xpc_partition *);
extern void xpc_deactivate_partition(const int, struct xpc_partition *,
- enum xp_retval);
+ enum xp_retval);
extern void xpc_mark_partition_inactive(struct xpc_partition *);
extern enum xp_retval xpc_register_remote_amos(struct xpc_partition *);
extern void xpc_unregister_remote_amos(struct xpc_partition *);
@@ -745,14 +703,13 @@ extern void xpc_discovery(void);
extern void xpc_check_remote_hb(void);
extern enum xp_retval xpc_initiate_partid_to_nasids(short, void *);

-
/* found in xpc_channel.c */
extern void xpc_initiate_connect(int);
extern void xpc_initiate_disconnect(int);
extern enum xp_retval xpc_initiate_allocate(short, int, u32, void **);
extern enum xp_retval xpc_initiate_send(short, int, void *);
extern enum xp_retval xpc_initiate_send_notify(short, int, void *,
- xpc_notify_func, void *);
+ xpc_notify_func, void *);
extern void xpc_initiate_received(short, int, void *);
extern enum xp_retval xpc_setup_infrastructure(struct xpc_partition *);
extern enum xp_retval xpc_pull_remote_vars_part(struct xpc_partition *);
@@ -760,13 +717,11 @@ extern void xpc_process_channel_activity
extern void xpc_connected_callout(struct xpc_channel *);
extern void xpc_deliver_msg(struct xpc_channel *);
extern void xpc_disconnect_channel(const int, struct xpc_channel *,
- enum xp_retval, unsigned long *);
+ enum xp_retval, unsigned long *);
extern void xpc_disconnect_callout(struct xpc_channel *, enum xp_retval);
extern void xpc_partition_going_down(struct xpc_partition *, enum xp_retval);
extern void xpc_teardown_infrastructure(struct xpc_partition *);

-
-
static inline void
xpc_wakeup_channel_mgr(struct xpc_partition *part)
{
@@ -775,8 +730,6 @@ xpc_wakeup_channel_mgr(struct xpc_partit
}
}

-
-
/*
* These next two inlines are used to keep us from tearing down a channel's
* msg queues while a thread may be referencing them.
@@ -798,12 +751,9 @@ xpc_msgqueue_deref(struct xpc_channel *c
}
}

-
-
#define XPC_DISCONNECT_CHANNEL(_ch, _reason, _irqflgs) \
xpc_disconnect_channel(__LINE__, _ch, _reason, _irqflgs)

-
/*
* These two inlines are used to keep us from tearing down a partition's
* setup infrastructure while a thread may be referencing it.
@@ -813,7 +763,6 @@ xpc_part_deref(struct xpc_partition *par
{
s32 refs = atomic_dec_return(&part->references);

-
DBUG_ON(refs < 0);
if (refs == 0 && part->setup_state == XPC_P_SS_WTEARDOWN) {
wake_up(&part->teardown_wq);
@@ -825,7 +774,6 @@ xpc_part_ref(struct xpc_partition *part)
{
int setup;

-
atomic_inc(&part->references);
setup = (part->setup_state == XPC_P_SS_SETUP);
if (!setup) {
@@ -834,8 +782,6 @@ xpc_part_ref(struct xpc_partition *part)
return setup;
}

-
-
/*
* The following macro is to be used for the setting of the reason and
* reason_line fields in both the struct xpc_channel and struct xpc_partition
@@ -847,8 +793,6 @@ xpc_part_ref(struct xpc_partition *part)
(_p)->reason_line = _line; \
}

-
-
/*
* This next set of inlines are used to keep track of when a partition is
* potentially engaged in accessing memory belonging to another partition.
@@ -858,8 +802,9 @@ static inline void
xpc_mark_partition_engaged(struct xpc_partition *part)
{
u64 *amo_va = __va(part->remote_amos_page_pa +
- (xpc_engaged_partitions_amos(part->remote_npartitions) +
- BIT_WORD(xp_partition_id)) * xp_sizeof_amo);
+ (xpc_engaged_partitions_amos
+ (part->remote_npartitions) +
+ BIT_WORD(xp_partition_id)) * xp_sizeof_amo);

/* set bit corresponding to our partid in remote partition's AMO */
(void)xp_set_amo(amo_va, XP_AMO_OR, BIT_MASK(xp_partition_id), 1);
@@ -869,8 +814,9 @@ static inline void
xpc_mark_partition_disengaged(struct xpc_partition *part)
{
u64 *amo_va = __va(part->remote_amos_page_pa +
- (xpc_engaged_partitions_amos(part->remote_npartitions) +
- BIT_WORD(xp_partition_id)) * xp_sizeof_amo);
+ (xpc_engaged_partitions_amos
+ (part->remote_npartitions) +
+ BIT_WORD(xp_partition_id)) * xp_sizeof_amo);

/* clear bit corresponding to our partid in remote partition's AMO */
(void)xp_set_amo(amo_va, XP_AMO_AND, ~BIT_MASK(xp_partition_id), 1);
@@ -880,8 +826,8 @@ static inline void
xpc_request_partition_disengage(struct xpc_partition *part)
{
u64 *amo_va = __va(part->remote_amos_page_pa +
- (xpc_disengage_request_amos(part->remote_npartitions) +
- BIT_WORD(xp_partition_id)) * xp_sizeof_amo);
+ (xpc_disengage_request_amos(part->remote_npartitions)
+ + BIT_WORD(xp_partition_id)) * xp_sizeof_amo);

/* set bit corresponding to our partid in remote partition's AMO */
(void)xp_set_amo(amo_va, XP_AMO_OR, BIT_MASK(xp_partition_id), 1);
@@ -891,8 +837,8 @@ static inline void
xpc_cancel_partition_disengage_request(struct xpc_partition *part)
{
u64 *amo_va = __va(part->remote_amos_page_pa +
- (xpc_disengage_request_amos(part->remote_npartitions) +
- BIT_WORD(xp_partition_id)) * xp_sizeof_amo);
+ (xpc_disengage_request_amos(part->remote_npartitions)
+ + BIT_WORD(xp_partition_id)) * xp_sizeof_amo);

/* clear bit corresponding to our partid in remote partition's AMO */
(void)xp_set_amo(amo_va, XP_AMO_AND, ~BIT_MASK(xp_partition_id), 1);
@@ -904,14 +850,15 @@ xpc_any_partition_engaged(void)
enum xp_retval ret;
int w_index;
u64 *amo_va = (u64 *)((u64)xpc_vars->amos_page +
- xpc_engaged_partitions_amos(xpc_vars->npartitions) *
- xp_sizeof_amo);
+ xpc_engaged_partitions_amos(xpc_vars->
+ npartitions) *
+ xp_sizeof_amo);
u64 amo;

for (w_index = 0; w_index < xp_partid_mask_words(xpc_vars->npartitions);
w_index++) {
ret = xp_get_amo(amo_va, XP_AMO_LOAD, &amo);
- BUG_ON(ret != xpSuccess); /* should never happen */
+ BUG_ON(ret != xpSuccess); /* should never happen */
if (amo != 0)
return 1;

@@ -925,13 +872,14 @@ xpc_partition_engaged(short partid)
{
enum xp_retval ret;
u64 *amo_va = (u64 *)((u64)xpc_vars->amos_page +
- (xpc_engaged_partitions_amos(xpc_vars->npartitions) +
- BIT_WORD(partid)) * xp_sizeof_amo);
+ (xpc_engaged_partitions_amos
+ (xpc_vars->npartitions) +
+ BIT_WORD(partid)) * xp_sizeof_amo);
u64 amo;

/* return our partition's AMO variable ANDed with partid mask */
ret = xp_get_amo(amo_va, XP_AMO_LOAD, &amo);
- BUG_ON(ret != xpSuccess); /* should never happen */
+ BUG_ON(ret != xpSuccess); /* should never happen */
return (amo & BIT_MASK(partid));
}

@@ -940,13 +888,14 @@ xpc_partition_disengage_requested(short
{
enum xp_retval ret;
u64 *amo_va = (u64 *)((u64)xpc_vars->amos_page +
- (xpc_disengage_request_amos(xpc_vars->npartitions) +
- BIT_WORD(partid)) * xp_sizeof_amo);
+ (xpc_disengage_request_amos
+ (xpc_vars->npartitions) +
+ BIT_WORD(partid)) * xp_sizeof_amo);
u64 amo;

/* return our partition's AMO variable ANDed with partid mask */
ret = xp_get_amo(amo_va, XP_AMO_LOAD, &amo);
- BUG_ON(ret != xpSuccess); /* should never happen */
+ BUG_ON(ret != xpSuccess); /* should never happen */
return (amo & BIT_MASK(partid));
}

@@ -955,12 +904,13 @@ xpc_clear_partition_engaged(short partid
{
enum xp_retval ret;
u64 *amo_va = (u64 *)((u64)xpc_vars->amos_page +
- (xpc_engaged_partitions_amos(xpc_vars->npartitions) +
- BIT_WORD(partid)) * xp_sizeof_amo);
+ (xpc_engaged_partitions_amos
+ (xpc_vars->npartitions) +
+ BIT_WORD(partid)) * xp_sizeof_amo);

/* clear bit corresponding to partid in our partition's AMO */
ret = xp_set_amo(amo_va, XP_AMO_AND, ~BIT_MASK(partid), 0);
- BUG_ON(ret != xpSuccess); /* should never happen */
+ BUG_ON(ret != xpSuccess); /* should never happen */
}

static inline void
@@ -968,16 +918,15 @@ xpc_clear_partition_disengage_request(sh
{
enum xp_retval ret;
u64 *amo_va = (u64 *)((u64)xpc_vars->amos_page +
- (xpc_disengage_request_amos(xpc_vars->npartitions) +
- BIT_WORD(partid)) * xp_sizeof_amo);
+ (xpc_disengage_request_amos
+ (xpc_vars->npartitions) +
+ BIT_WORD(partid)) * xp_sizeof_amo);

/* clear bit corresponding to partid in our partition's AMO */
ret = xp_set_amo(amo_va, XP_AMO_AND, ~BIT_MASK(partid), 0);
- BUG_ON(ret != xpSuccess); /* should never happen */
+ BUG_ON(ret != xpSuccess); /* should never happen */
}

-
-
/*
* The following set of macros and inlines are used for the sending and
* receiving of IPIs (also known as IRQs). There are two flavors of IPIs,
@@ -1000,13 +949,13 @@ xpc_activate_IRQ_send(u64 amos_page_pa,
/* SN nodes are always even numbered nasids */
u64 *amo_va = (u64 *)__va(amos_page_pa +
(xpc_activate_irq_amos(npartitions) +
- BIT_WORD(from_nasid/2)) * xp_sizeof_amo);
+ BIT_WORD(from_nasid / 2)) * xp_sizeof_amo);

ret = xp_set_amo_with_interrupt(amo_va, XP_AMO_OR,
- BIT_MASK(from_nasid/2),
+ BIT_MASK(from_nasid / 2),
remote_amo, to_nasid,
to_phys_cpuid, SGI_XPC_ACTIVATE);
- BUG_ON(!remote_amo && ret != xpSuccess); /* should never happen*/
+ BUG_ON(!remote_amo && ret != xpSuccess); /* should never happen */
}

static inline void
@@ -1043,7 +992,6 @@ xpc_IPI_send_disengage(struct xpc_partit
part->remote_npartitions);
}

-
/*
* IPIs associated with SGI_XPC_NOTIFY IRQ.
*/
@@ -1057,12 +1005,11 @@ xpc_IPI_send_disengage(struct xpc_partit

static inline void
xpc_notify_IRQ_send(struct xpc_channel *ch, u8 ipi_flag, char *ipi_flag_string,
- unsigned long *irq_flags)
+ unsigned long *irq_flags)
{
struct xpc_partition *part = &xpc_partitions[ch->partid];
enum xp_retval ret;

-
if (unlikely(part->act_state == XPC_P_AS_DEACTIVATING))
return;

@@ -1082,7 +1029,6 @@ xpc_notify_IRQ_send(struct xpc_channel *
}
}

-
/*
* Make it look like the remote partition, which is associated with the
* specified channel, sent us an IPI. This faked IPI will be handled
@@ -1093,21 +1039,21 @@ xpc_notify_IRQ_send(struct xpc_channel *

static inline void
xpc_notify_IRQ_send_local(struct xpc_channel *ch, u8 ipi_flag,
- char *ipi_flag_string)
+ char *ipi_flag_string)
{
enum xp_retval ret;
u64 *amo_va = xpc_partitions[ch->partid].local_IPI_amo_va;

/* set IPI flag corresponding to channel in partition's local AMO */
- ret = xp_set_amo(amo_va, XP_AMO_OR, ((u64)ipi_flag << (ch->number * 8)),
- 0);
- BUG_ON(ret != xpSuccess); /* should never happen */
+ ret =
+ xp_set_amo(amo_va, XP_AMO_OR, ((u64)ipi_flag << (ch->number * 8)),
+ 0);
+ BUG_ON(ret != xpSuccess); /* should never happen */

dev_dbg(xpc_chan, "%s sent local from partid=%d, channel=%d\n",
ipi_flag_string, ch->partid, ch->number);
}

-
/*
* The sending and receiving of IPIs includes the setting of an AMO variable
* to indicate the reason the IPI was sent. The 64-bit variable is divided
@@ -1122,7 +1068,6 @@ xpc_notify_IRQ_send_local(struct xpc_cha
#define XPC_IPI_OPENREPLY 0x08
#define XPC_IPI_MSGREQUEST 0x10

-
/* given an AMO variable and a channel#, get its associated IPI flags */
#define XPC_GET_IPI_FLAGS(_amo, _c) ((u8) (((_amo) >> ((_c) * 8)) & 0xff))
#define XPC_SET_IPI_FLAGS(_amo, _c, _f) (_amo) |= ((u64) (_f) << ((_c) * 8))
@@ -1130,13 +1075,11 @@ xpc_notify_IRQ_send_local(struct xpc_cha
#define XPC_ANY_OPENCLOSE_IPI_FLAGS_SET(_amo) ((_amo) & 0x0f0f0f0f0f0f0f0fUL)
#define XPC_ANY_MSG_IPI_FLAGS_SET(_amo) ((_amo) & 0x1010101010101010UL)

-
static inline void
xpc_IPI_send_closerequest(struct xpc_channel *ch, unsigned long *irq_flags)
{
struct xpc_openclose_args *args = ch->local_openclose_args;

-
args->reason = ch->reason;

XPC_NOTIFY_IRQ_SEND(ch, XPC_IPI_CLOSEREQUEST, irq_flags);
@@ -1153,7 +1096,6 @@ xpc_IPI_send_openrequest(struct xpc_chan
{
struct xpc_openclose_args *args = ch->local_openclose_args;

-
args->msg_size = ch->msg_size;
args->local_nentries = ch->local_nentries;

@@ -1165,7 +1107,6 @@ xpc_IPI_send_openreply(struct xpc_channe
{
struct xpc_openclose_args *args = ch->local_openclose_args;

-
args->remote_nentries = ch->remote_nentries;
args->local_nentries = ch->local_nentries;
args->local_msgqueue_pa = __pa(ch->local_msgqueue);
@@ -1185,21 +1126,17 @@ xpc_IPI_send_local_msgrequest(struct xpc
XPC_NOTIFY_IRQ_SEND_LOCAL(ch, XPC_IPI_MSGREQUEST);
}

-
static inline u64 *
xpc_IPI_init(int index)
{
enum xp_retval ret;
- u64 *amo_va = (u64 *)((u64)xpc_vars->amos_page + index *
- xp_sizeof_amo);
+ u64 *amo_va = (u64 *)((u64)xpc_vars->amos_page + index * xp_sizeof_amo);

ret = xp_get_amo(amo_va, XP_AMO_CLEAR, NULL);
- BUG_ON(ret != xpSuccess); /* should never happen */
+ BUG_ON(ret != xpSuccess); /* should never happen */
return amo_va;
}

-
-
/*
* Check to see if there is any channel activity to/from the specified
* partition.
@@ -1211,9 +1148,8 @@ xpc_check_for_channel_activity(struct xp
u64 IPI_amo;
unsigned long irq_flags;

-
ret = xp_get_amo(part->local_IPI_amo_va, XP_AMO_CLEAR, &IPI_amo);
- BUG_ON(ret != xpSuccess); /* should never happen */
+ BUG_ON(ret != xpSuccess); /* should never happen */
if (IPI_amo == 0) {
return;
}
@@ -1228,6 +1164,4 @@ xpc_check_for_channel_activity(struct xp
xpc_wakeup_channel_mgr(part);
}

-
#endif /* _DRIVERS_MISC_XP_XPC_H */
-
Index: linux-2.6/drivers/misc/xp/xpc_channel.c
===================================================================
--- linux-2.6.orig/drivers/misc/xp/xpc_channel.c 2008-03-21 13:30:52.034175000 -0500
+++ linux-2.6/drivers/misc/xp/xpc_channel.c 2008-03-24 19:31:37.154185684 -0500
@@ -6,7 +6,6 @@
* Copyright (c) 2004-2008 Silicon Graphics, Inc. All Rights Reserved.
*/

-
/*
* Cross Partition Communication (XPC) channel support.
*
@@ -15,7 +14,6 @@
*
*/

-
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/sched.h>
@@ -29,7 +27,6 @@
#define cmpxchg_rel(ptr,o,n) cmpxchg(ptr,o,n)
#endif

-
/*
* Guarantee that the kzalloc'd memory is cacheline aligned.
*/
@@ -41,7 +38,7 @@ xpc_kzalloc_cacheline_aligned(size_t siz
if (*base == NULL) {
return NULL;
}
- if ((u64) *base == L1_CACHE_ALIGN((u64) *base)) {
+ if ((u64)*base == L1_CACHE_ALIGN((u64)*base)) {
return *base;
}
kfree(*base);
@@ -51,10 +48,9 @@ xpc_kzalloc_cacheline_aligned(size_t siz
if (*base == NULL) {
return NULL;
}
- return (void *) L1_CACHE_ALIGN((u64) *base);
+ return (void *)L1_CACHE_ALIGN((u64)*base);
}

-
/*
* Set up the initial values for the XPartition Communication channels.
*/
@@ -64,7 +60,6 @@ xpc_initialize_channels(struct xpc_parti
int ch_number;
struct xpc_channel *ch;

-
for (ch_number = 0; ch_number < part->nchannels; ch_number++) {
ch = &part->channels[ch_number];

@@ -74,7 +69,7 @@ xpc_initialize_channels(struct xpc_parti

ch->local_GP = &part->local_GPs[ch_number];
ch->local_openclose_args =
- &part->local_openclose_args[ch_number];
+ &part->local_openclose_args[ch_number];

atomic_set(&ch->kthreads_assigned, 0);
atomic_set(&ch->kthreads_idle, 0);
@@ -93,7 +88,6 @@ xpc_initialize_channels(struct xpc_parti
}
}

-
/*
* Setup the infrastructure necessary to support XPartition Communication
* between the specified remote partition and the local one.
@@ -105,7 +99,6 @@ xpc_setup_infrastructure(struct xpc_part
struct timer_list *timer;
short partid = XPC_PARTID(part);

-
/*
* Zero out MOST of the entry for this partition. Only the fields
* starting with `nchannels' will be zeroed. The preceding fields must
@@ -113,14 +106,14 @@ xpc_setup_infrastructure(struct xpc_part
* referenced during this memset() operation.
*/
memset(&part->nchannels, 0, sizeof(struct xpc_partition) -
- offsetof(struct xpc_partition, nchannels));
+ offsetof(struct xpc_partition, nchannels));

/*
* Allocate all of the channel structures as a contiguous chunk of
* memory.
*/
part->channels = kzalloc(sizeof(struct xpc_channel) * XPC_NCHANNELS,
- GFP_KERNEL);
+ GFP_KERNEL);
if (part->channels == NULL) {
dev_err(xpc_chan, "can't get memory for channels\n");
return xpNoMemory;
@@ -128,11 +121,11 @@ xpc_setup_infrastructure(struct xpc_part

part->nchannels = XPC_NCHANNELS;

-
/* allocate all the required GET/PUT values */

part->local_GPs = xpc_kzalloc_cacheline_aligned(XPC_GP_SIZE,
- GFP_KERNEL, &part->local_GPs_base);
+ GFP_KERNEL,
+ &part->local_GPs_base);
if (part->local_GPs == NULL) {
kfree(part->channels);
part->channels = NULL;
@@ -142,7 +135,9 @@ xpc_setup_infrastructure(struct xpc_part
}

part->remote_GPs = xpc_kzalloc_cacheline_aligned(XPC_GP_SIZE,
- GFP_KERNEL, &part->remote_GPs_base);
+ GFP_KERNEL,
+ &part->
+ remote_GPs_base);
if (part->remote_GPs == NULL) {
dev_err(xpc_chan, "can't get memory for remote get/put "
"values\n");
@@ -153,12 +148,11 @@ xpc_setup_infrastructure(struct xpc_part
return xpNoMemory;
}

-
/* allocate all the required open and close args */

- part->local_openclose_args = xpc_kzalloc_cacheline_aligned(
- XPC_OPENCLOSE_ARGS_SIZE, GFP_KERNEL,
- &part->local_openclose_args_base);
+ part->local_openclose_args =
+ xpc_kzalloc_cacheline_aligned(XPC_OPENCLOSE_ARGS_SIZE, GFP_KERNEL,
+ &part->local_openclose_args_base);
if (part->local_openclose_args == NULL) {
dev_err(xpc_chan, "can't get memory for local connect args\n");
kfree(part->remote_GPs_base);
@@ -170,9 +164,9 @@ xpc_setup_infrastructure(struct xpc_part
return xpNoMemory;
}

- part->remote_openclose_args = xpc_kzalloc_cacheline_aligned(
- XPC_OPENCLOSE_ARGS_SIZE, GFP_KERNEL,
- &part->remote_openclose_args_base);
+ part->remote_openclose_args =
+ xpc_kzalloc_cacheline_aligned(XPC_OPENCLOSE_ARGS_SIZE, GFP_KERNEL,
+ &part->remote_openclose_args_base);
if (part->remote_openclose_args == NULL) {
dev_err(xpc_chan, "can't get memory for remote connect args\n");
kfree(part->local_openclose_args_base);
@@ -186,13 +180,11 @@ xpc_setup_infrastructure(struct xpc_part
return xpNoMemory;
}

-
xpc_initialize_channels(part, partid);

atomic_set(&part->nchannels_active, 0);
atomic_set(&part->nchannels_engaged, 0);

-
/* local_IPI_amo were set to 0 by an earlier memset() */

/* Initialize this partitions AMO structure */
@@ -205,7 +197,7 @@ xpc_setup_infrastructure(struct xpc_part

sprintf(part->IPI_owner, "xpc%02d", partid);
ret = request_irq(SGI_XPC_NOTIFY, xpc_notify_IRQ_handler, IRQF_SHARED,
- part->IPI_owner, (void *) (u64) partid);
+ part->IPI_owner, (void *)(u64)partid);
if (ret != 0) {
dev_err(xpc_chan, "can't register NOTIFY IRQ handler, "
"errno=%d\n", -ret);
@@ -225,8 +217,8 @@ xpc_setup_infrastructure(struct xpc_part
/* Setup a timer to check for dropped IPIs */
timer = &part->dropped_IPI_timer;
init_timer(timer);
- timer->function = (void (*)(unsigned long)) xpc_dropped_IPI_check;
- timer->data = (unsigned long) part;
+ timer->function = (void (*)(unsigned long))xpc_dropped_IPI_check;
+ timer->data = (unsigned long)part;
timer->expires = jiffies + XPC_DROPPED_IPI_WAIT_INTERVAL;
add_timer(timer);

@@ -236,7 +228,6 @@ xpc_setup_infrastructure(struct xpc_part
*/
part->setup_state = XPC_P_SS_SETUP;

-
/*
* Setup the per partition specific variables required by the
* remote partition to establish channel connections with us.
@@ -246,7 +237,7 @@ xpc_setup_infrastructure(struct xpc_part
*/
xpc_vars_part[partid].GPs_pa = __pa(part->local_GPs);
xpc_vars_part[partid].openclose_args_pa =
- __pa(part->local_openclose_args);
+ __pa(part->local_openclose_args);
xpc_vars_part[partid].IPI_amo_pa = __pa(part->local_IPI_amo_va);
cpuid = raw_smp_processor_id(); /* any CPU in this partition will do */
xpc_vars_part[partid].IPI_nasid = xp_cpu_to_nasid(cpuid);
@@ -257,7 +248,6 @@ xpc_setup_infrastructure(struct xpc_part
return xpSuccess;
}

-
/*
* Create a wrapper that hides the underlying mechanism for pulling a cacheline
* (or multiple cachelines) from a remote partition.
@@ -268,13 +258,12 @@ xpc_setup_infrastructure(struct xpc_part
*/
static enum xp_retval
xpc_pull_remote_cachelines(struct xpc_partition *part, void *dst,
- const void *src, size_t cnt)
+ const void *src, size_t cnt)
{
enum xp_retval ret;

-
- DBUG_ON((u64) src != L1_CACHE_ALIGN((u64) src));
- DBUG_ON((u64) dst != L1_CACHE_ALIGN((u64) dst));
+ DBUG_ON((u64)src != L1_CACHE_ALIGN((u64)src));
+ DBUG_ON((u64)dst != L1_CACHE_ALIGN((u64)dst));
DBUG_ON(cnt != L1_CACHE_ALIGN(cnt));

if (part->act_state == XPC_P_AS_DEACTIVATING) {
@@ -290,7 +279,6 @@ xpc_pull_remote_cachelines(struct xpc_pa
return ret;
}

-
/*
* Pull the remote per partition specific variables from the specified
* partition.
@@ -300,41 +288,40 @@ xpc_pull_remote_vars_part(struct xpc_par
{
u8 buffer[L1_CACHE_BYTES * 2];
struct xpc_vars_part *pulled_entry_cacheline =
- (struct xpc_vars_part *) L1_CACHE_ALIGN((u64) buffer);
+ (struct xpc_vars_part *)L1_CACHE_ALIGN((u64)buffer);
struct xpc_vars_part *pulled_entry;
u64 remote_entry_cacheline_pa, remote_entry_pa;
short partid = XPC_PARTID(part);
enum xp_retval ret;

-
/* pull the cacheline that contains the variables we're interested in */

DBUG_ON(part->remote_vars_part_pa !=
- L1_CACHE_ALIGN(part->remote_vars_part_pa));
+ L1_CACHE_ALIGN(part->remote_vars_part_pa));
DBUG_ON(sizeof(struct xpc_vars_part) != L1_CACHE_BYTES / 2);

remote_entry_pa = part->remote_vars_part_pa +
- xp_partition_id * sizeof(struct xpc_vars_part);
+ xp_partition_id * sizeof(struct xpc_vars_part);

remote_entry_cacheline_pa = (remote_entry_pa & ~(L1_CACHE_BYTES - 1));

- pulled_entry = (struct xpc_vars_part *) ((u64) pulled_entry_cacheline +
- (remote_entry_pa & (L1_CACHE_BYTES - 1)));
+ pulled_entry = (struct xpc_vars_part *)((u64)pulled_entry_cacheline +
+ (remote_entry_pa &
+ (L1_CACHE_BYTES - 1)));

ret = xpc_pull_remote_cachelines(part, pulled_entry_cacheline,
- (void *) remote_entry_cacheline_pa,
- L1_CACHE_BYTES);
+ (void *)remote_entry_cacheline_pa,
+ L1_CACHE_BYTES);
if (ret != xpSuccess) {
dev_dbg(xpc_chan, "failed to pull XPC vars_part from "
"partition %d, ret=%d\n", partid, ret);
return ret;
}

-
/* see if they've been set up yet */

if (pulled_entry->magic != XPC_VP_MAGIC1 &&
- pulled_entry->magic != XPC_VP_MAGIC2) {
+ pulled_entry->magic != XPC_VP_MAGIC2) {

if (pulled_entry->magic != 0) {
dev_dbg(xpc_chan, "partition %d's XPC vars_part for "
@@ -353,8 +340,8 @@ xpc_pull_remote_vars_part(struct xpc_par
/* validate the variables */

if (pulled_entry->GPs_pa == 0 ||
- pulled_entry->openclose_args_pa == 0 ||
- pulled_entry->IPI_amo_pa == 0) {
+ pulled_entry->openclose_args_pa == 0 ||
+ pulled_entry->IPI_amo_pa == 0) {

dev_err(xpc_chan, "partition %d's XPC vars_part for "
"partition %d are not valid\n", partid,
@@ -366,7 +353,7 @@ xpc_pull_remote_vars_part(struct xpc_par

part->remote_GPs_pa = pulled_entry->GPs_pa;
part->remote_openclose_args_pa =
- pulled_entry->openclose_args_pa;
+ pulled_entry->openclose_args_pa;
part->remote_IPI_amo_va = __va(pulled_entry->IPI_amo_pa);
part->remote_IPI_nasid = pulled_entry->IPI_nasid;
part->remote_IPI_phys_cpuid = pulled_entry->IPI_phys_cpuid;
@@ -387,7 +374,6 @@ xpc_pull_remote_vars_part(struct xpc_par
return xpSuccess;
}

-
/*
* Get the IPI flags and pull the openclose args and/or remote GPs as needed.
*/
@@ -398,7 +384,6 @@ xpc_get_IPI_flags(struct xpc_partition *
u64 IPI_amo;
enum xp_retval ret;

-
/*
* See if there are any IPI flags to be handled.
*/
@@ -409,12 +394,12 @@ xpc_get_IPI_flags(struct xpc_partition *
}
spin_unlock_irqrestore(&part->IPI_lock, irq_flags);

-
if (XPC_ANY_OPENCLOSE_IPI_FLAGS_SET(IPI_amo)) {
ret = xpc_pull_remote_cachelines(part,
- part->remote_openclose_args,
- (void *) part->remote_openclose_args_pa,
- XPC_OPENCLOSE_ARGS_SIZE);
+ part->remote_openclose_args,
+ (void *)part->
+ remote_openclose_args_pa,
+ XPC_OPENCLOSE_ARGS_SIZE);
if (ret != xpSuccess) {
XPC_DEACTIVATE_PARTITION(part, ret);

@@ -429,8 +414,8 @@ xpc_get_IPI_flags(struct xpc_partition *

if (XPC_ANY_MSG_IPI_FLAGS_SET(IPI_amo)) {
ret = xpc_pull_remote_cachelines(part, part->remote_GPs,
- (void *) part->remote_GPs_pa,
- XPC_GP_SIZE);
+ (void *)part->remote_GPs_pa,
+ XPC_GP_SIZE);
if (ret != xpSuccess) {
XPC_DEACTIVATE_PARTITION(part, ret);

@@ -445,7 +430,6 @@ xpc_get_IPI_flags(struct xpc_partition *
return IPI_amo;
}

-
/*
* Allocate the local message queue and the notify queue.
*/
@@ -460,8 +444,9 @@ xpc_allocate_local_msgqueue(struct xpc_c

nbytes = nentries * ch->msg_size;
ch->local_msgqueue = xpc_kzalloc_cacheline_aligned(nbytes,
- GFP_KERNEL,
- &ch->local_msgqueue_base);
+ GFP_KERNEL,
+ &ch->
+ local_msgqueue_base);
if (ch->local_msgqueue == NULL) {
continue;
}
@@ -491,7 +476,6 @@ xpc_allocate_local_msgqueue(struct xpc_c
return xpNoMemory;
}

-
/*
* Allocate the cached remote message queue.
*/
@@ -502,15 +486,15 @@ xpc_allocate_remote_msgqueue(struct xpc_
int nentries;
size_t nbytes;

-
DBUG_ON(ch->remote_nentries <= 0);

for (nentries = ch->remote_nentries; nentries > 0; nentries--) {

nbytes = nentries * ch->msg_size;
ch->remote_msgqueue = xpc_kzalloc_cacheline_aligned(nbytes,
- GFP_KERNEL,
- &ch->remote_msgqueue_base);
+ GFP_KERNEL,
+ &ch->
+ remote_msgqueue_base);
if (ch->remote_msgqueue == NULL) {
continue;
}
@@ -532,7 +516,6 @@ xpc_allocate_remote_msgqueue(struct xpc_
return xpNoMemory;
}

-
/*
* Allocate message queues and other stuff associated with a channel.
*
@@ -544,7 +527,6 @@ xpc_allocate_msgqueues(struct xpc_channe
unsigned long irq_flags;
enum xp_retval ret;

-
DBUG_ON(ch->flags & XPC_C_SETUP);

if ((ret = xpc_allocate_local_msgqueue(ch)) != xpSuccess) {
@@ -566,7 +548,6 @@ xpc_allocate_msgqueues(struct xpc_channe
return xpSuccess;
}

-
/*
* Process a connect message from a remote partition.
*
@@ -578,11 +559,10 @@ xpc_process_connect(struct xpc_channel *
{
enum xp_retval ret;

-
DBUG_ON(!spin_is_locked(&ch->lock));

if (!(ch->flags & XPC_C_OPENREQUEST) ||
- !(ch->flags & XPC_C_ROPENREQUEST)) {
+ !(ch->flags & XPC_C_ROPENREQUEST)) {
/* nothing more to do for now */
return;
}
@@ -619,14 +599,13 @@ xpc_process_connect(struct xpc_channel *
ch->flags = (XPC_C_CONNECTED | XPC_C_SETUP); /* clear all else */

dev_info(xpc_chan, "channel %d to partition %d connected\n",
- ch->number, ch->partid);
+ ch->number, ch->partid);

spin_unlock_irqrestore(&ch->lock, *irq_flags);
xpc_create_kthreads(ch, 1, 0);
spin_lock_irqsave(&ch->lock, *irq_flags);
}

-
/*
* Notify those who wanted to be notified upon delivery of their message.
*/
@@ -637,7 +616,6 @@ xpc_notify_senders(struct xpc_channel *c
u8 notify_type;
s64 get = ch->w_remote_GP.get - 1;

-
while (++get < put && atomic_read(&ch->n_to_notify) > 0) {

notify = &ch->notify_queue[get % ch->local_nentries];
@@ -650,8 +628,7 @@ xpc_notify_senders(struct xpc_channel *c
*/
notify_type = notify->type;
if (notify_type == 0 ||
- cmpxchg(&notify->type, notify_type, 0) !=
- notify_type) {
+ cmpxchg(&notify->type, notify_type, 0) != notify_type) {
continue;
}

@@ -662,21 +639,20 @@ xpc_notify_senders(struct xpc_channel *c
if (notify->func != NULL) {
dev_dbg(xpc_chan, "notify->func() called, notify=0x%p, "
"msg_number=%" U64_ELL "d, partid=%d, "
- "channel=%d\n", (void *) notify, get,
+ "channel=%d\n", (void *)notify, get,
ch->partid, ch->number);

notify->func(reason, ch->partid, ch->number,
- notify->key);
+ notify->key);

dev_dbg(xpc_chan, "notify->func() returned, "
"notify=0x%p, msg_number=%" U64_ELL "d, "
- "partid=%d, channel=%d\n", (void *) notify,
+ "partid=%d, channel=%d\n", (void *)notify,
get, ch->partid, ch->number);
}
}
}

-
/*
* Free up message queues and other stuff that were allocated for the specified
* channel.
@@ -724,7 +700,6 @@ xpc_free_msgqueues(struct xpc_channel *c
}
}

-
/*
* spin_lock_irqsave() is expected to be held on entry.
*/
@@ -734,7 +709,6 @@ xpc_process_disconnect(struct xpc_channe
struct xpc_partition *part = &xpc_partitions[ch->partid];
u32 channel_was_connected = (ch->flags & XPC_C_WASCONNECTED);

-
DBUG_ON(!spin_is_locked(&ch->lock));

if (!(ch->flags & XPC_C_DISCONNECTING)) {
@@ -746,11 +720,11 @@ xpc_process_disconnect(struct xpc_channe
/* make sure all activity has settled down first */

if (atomic_read(&ch->kthreads_assigned) > 0 ||
- atomic_read(&ch->references) > 0) {
+ atomic_read(&ch->references) > 0) {
return;
}
DBUG_ON((ch->flags & XPC_C_CONNECTEDCALLOUT_MADE) &&
- !(ch->flags & XPC_C_DISCONNECTINGCALLOUT_MADE));
+ !(ch->flags & XPC_C_DISCONNECTINGCALLOUT_MADE));

if (part->act_state == XPC_P_AS_DEACTIVATING) {
/* can't proceed until the other side disengages from us */
@@ -800,7 +774,7 @@ xpc_process_disconnect(struct xpc_channe

if (channel_was_connected) {
dev_info(xpc_chan, "channel %d to partition %d disconnected, "
- "reason=%d\n", ch->number, ch->partid, ch->reason);
+ "reason=%d\n", ch->number, ch->partid, ch->reason);
}

if (ch->flags & XPC_C_WDISCONNECT) {
@@ -811,35 +785,31 @@ xpc_process_disconnect(struct xpc_channe
/* time to take action on any delayed IPI flags */
spin_lock(&part->IPI_lock);
XPC_SET_IPI_FLAGS(part->local_IPI_amo, ch->number,
- ch->delayed_IPI_flags);
+ ch->delayed_IPI_flags);
spin_unlock(&part->IPI_lock);
}
ch->delayed_IPI_flags = 0;
}
}

-
/*
* Process a change in the channel's remote connection state.
*/
static void
xpc_process_openclose_IPI(struct xpc_partition *part, int ch_number,
- u8 IPI_flags)
+ u8 IPI_flags)
{
unsigned long irq_flags;
struct xpc_openclose_args *args =
- &part->remote_openclose_args[ch_number];
+ &part->remote_openclose_args[ch_number];
struct xpc_channel *ch = &part->channels[ch_number];
enum xp_retval reason;

-
-
spin_lock_irqsave(&ch->lock, irq_flags);

-again:
+ again:

- if ((ch->flags & XPC_C_DISCONNECTED) &&
- (ch->flags & XPC_C_WDISCONNECT)) {
+ if ((ch->flags & XPC_C_DISCONNECTED) && (ch->flags & XPC_C_WDISCONNECT)) {
/*
* Delay processing IPI flags until thread waiting disconnect
* has had a chance to see that the channel is disconnected.
@@ -849,7 +819,6 @@ again:
return;
}

-
if (IPI_flags & XPC_IPI_CLOSEREQUEST) {

dev_dbg(xpc_chan, "XPC_IPI_CLOSEREQUEST (reason=%d) received "
@@ -881,13 +850,14 @@ again:
if (ch->flags & XPC_C_DISCONNECTED) {
if (!(IPI_flags & XPC_IPI_OPENREQUEST)) {
if ((XPC_GET_IPI_FLAGS(part->local_IPI_amo,
- ch_number) & XPC_IPI_OPENREQUEST)) {
+ ch_number) &
+ XPC_IPI_OPENREQUEST)) {

DBUG_ON(ch->delayed_IPI_flags != 0);
spin_lock(&part->IPI_lock);
XPC_SET_IPI_FLAGS(part->local_IPI_amo,
- ch_number,
- XPC_IPI_CLOSEREQUEST);
+ ch_number,
+ XPC_IPI_CLOSEREQUEST);
spin_unlock(&part->IPI_lock);
}
spin_unlock_irqrestore(&ch->lock, irq_flags);
@@ -928,7 +898,6 @@ again:
xpc_process_disconnect(ch, &irq_flags);
}

-
if (IPI_flags & XPC_IPI_CLOSEREPLY) {

dev_dbg(xpc_chan, "XPC_IPI_CLOSEREPLY received from partid=%d,"
@@ -944,12 +913,13 @@ again:

if (!(ch->flags & XPC_C_RCLOSEREQUEST)) {
if ((XPC_GET_IPI_FLAGS(part->local_IPI_amo, ch_number)
- & XPC_IPI_CLOSEREQUEST)) {
+ & XPC_IPI_CLOSEREQUEST)) {

DBUG_ON(ch->delayed_IPI_flags != 0);
spin_lock(&part->IPI_lock);
XPC_SET_IPI_FLAGS(part->local_IPI_amo,
- ch_number, XPC_IPI_CLOSEREPLY);
+ ch_number,
+ XPC_IPI_CLOSEREPLY);
spin_unlock(&part->IPI_lock);
}
spin_unlock_irqrestore(&ch->lock, irq_flags);
@@ -964,7 +934,6 @@ again:
}
}

-
if (IPI_flags & XPC_IPI_OPENREQUEST) {

dev_dbg(xpc_chan, "XPC_IPI_OPENREQUEST (msg_size=%d, "
@@ -973,7 +942,7 @@ again:
ch->partid, ch->number);

if (part->act_state == XPC_P_AS_DEACTIVATING ||
- (ch->flags & XPC_C_ROPENREQUEST)) {
+ (ch->flags & XPC_C_ROPENREQUEST)) {
spin_unlock_irqrestore(&ch->lock, irq_flags);
return;
}
@@ -984,9 +953,9 @@ again:
return;
}
DBUG_ON(!(ch->flags & (XPC_C_DISCONNECTED |
- XPC_C_OPENREQUEST)));
+ XPC_C_OPENREQUEST)));
DBUG_ON(ch->flags & (XPC_C_ROPENREQUEST | XPC_C_ROPENREPLY |
- XPC_C_OPENREPLY | XPC_C_CONNECTED));
+ XPC_C_OPENREPLY | XPC_C_CONNECTED));

/*
* The meaningful OPENREQUEST connection state fields are:
@@ -1002,11 +971,10 @@ again:
ch->flags |= (XPC_C_ROPENREQUEST | XPC_C_CONNECTING);
ch->remote_nentries = args->local_nentries;

-
if (ch->flags & XPC_C_OPENREQUEST) {
if (args->msg_size != ch->msg_size) {
XPC_DISCONNECT_CHANNEL(ch, xpUnequalMsgSizes,
- &irq_flags);
+ &irq_flags);
spin_unlock_irqrestore(&ch->lock, irq_flags);
return;
}
@@ -1022,7 +990,6 @@ again:
xpc_process_connect(ch, &irq_flags);
}

-
if (IPI_flags & XPC_IPI_OPENREPLY) {

dev_dbg(xpc_chan, "XPC_IPI_OPENREPLY (local_msgqueue_pa=0x%"
@@ -1037,7 +1004,7 @@ again:
}
if (!(ch->flags & XPC_C_OPENREQUEST)) {
XPC_DISCONNECT_CHANNEL(ch, xpOpenCloseError,
- &irq_flags);
+ &irq_flags);
spin_unlock_irqrestore(&ch->lock, irq_flags);
return;
}
@@ -1048,7 +1015,7 @@ again:
/*
* The meaningful OPENREPLY connection state fields are:
* local_msgqueue_pa = physical address of remote
- * partition's local_msgqueue
+ * partition's local_msgqueue
* local_nentries = remote partition's local_nentries
* remote_nentries = remote partition's remote_nentries
*/
@@ -1084,7 +1051,6 @@ again:
spin_unlock_irqrestore(&ch->lock, irq_flags);
}

-
/*
* Attempt to establish a channel connection to a remote partition.
*/
@@ -1094,7 +1060,6 @@ xpc_connect_channel(struct xpc_channel *
unsigned long irq_flags;
struct xpc_registration *registration = &xpc_registrations[ch->number];

-
if (mutex_trylock(&registration->mutex) == 0) {
return xpRetry;
}
@@ -1115,7 +1080,6 @@ xpc_connect_channel(struct xpc_channel *
return ch->reason;
}

-
/* add info from the channel connect registration to the channel */

ch->kthreads_assigned_limit = registration->assigned_limit;
@@ -1145,7 +1109,7 @@ xpc_connect_channel(struct xpc_channel *
*/
mutex_unlock(&registration->mutex);
XPC_DISCONNECT_CHANNEL(ch, xpUnequalMsgSizes,
- &irq_flags);
+ &irq_flags);
spin_unlock_irqrestore(&ch->lock, irq_flags);
return xpUnequalMsgSizes;
}
@@ -1160,7 +1124,6 @@ xpc_connect_channel(struct xpc_channel *

mutex_unlock(&registration->mutex);

-
/* initiate the connection */

ch->flags |= (XPC_C_OPENREQUEST | XPC_C_CONNECTING);
@@ -1173,7 +1136,6 @@ xpc_connect_channel(struct xpc_channel *
return xpSuccess;
}

-
/*
* Clear some of the msg flags in the local message queue.
*/
@@ -1183,16 +1145,15 @@ xpc_clear_local_msgqueue_flags(struct xp
struct xpc_msg *msg;
s64 get;

-
get = ch->w_remote_GP.get;
do {
- msg = (struct xpc_msg *) ((u64) ch->local_msgqueue +
- (get % ch->local_nentries) * ch->msg_size);
+ msg = (struct xpc_msg *)((u64)ch->local_msgqueue +
+ (get % ch->local_nentries) *
+ ch->msg_size);
msg->flags = 0;
- } while (++get < (volatile s64) ch->remote_GP.get);
+ } while (++get < (volatile s64)ch->remote_GP.get);
}

-
/*
* Clear some of the msg flags in the remote message queue.
*/
@@ -1202,43 +1163,39 @@ xpc_clear_remote_msgqueue_flags(struct x
struct xpc_msg *msg;
s64 put;

-
put = ch->w_remote_GP.put;
do {
- msg = (struct xpc_msg *) ((u64) ch->remote_msgqueue +
- (put % ch->remote_nentries) * ch->msg_size);
+ msg = (struct xpc_msg *)((u64)ch->remote_msgqueue +
+ (put % ch->remote_nentries) *
+ ch->msg_size);
msg->flags = 0;
- } while (++put < (volatile s64) ch->remote_GP.put);
+ } while (++put < (volatile s64)ch->remote_GP.put);
}

-
static void
xpc_process_msg_IPI(struct xpc_partition *part, int ch_number)
{
struct xpc_channel *ch = &part->channels[ch_number];
int nmsgs_sent;

-
ch->remote_GP = part->remote_GPs[ch_number];

-
/* See what, if anything, has changed for each connected channel */

xpc_msgqueue_ref(ch);

if (ch->w_remote_GP.get == ch->remote_GP.get &&
- ch->w_remote_GP.put == ch->remote_GP.put) {
+ ch->w_remote_GP.put == ch->remote_GP.put) {
/* nothing changed since GPs were last pulled */
xpc_msgqueue_deref(ch);
return;
}

- if (!(ch->flags & XPC_C_CONNECTED)){
+ if (!(ch->flags & XPC_C_CONNECTED)) {
xpc_msgqueue_deref(ch);
return;
}

-
/*
* First check to see if messages recently sent by us have been
* received by the other side. (The remote GET value will have
@@ -1260,7 +1217,7 @@ xpc_process_msg_IPI(struct xpc_partition
* received and delivered by the other side.
*/
xpc_notify_senders(ch, xpMsgDelivered,
- ch->remote_GP.get);
+ ch->remote_GP.get);
}

/*
@@ -1284,7 +1241,6 @@ xpc_process_msg_IPI(struct xpc_partition
}
}

-
/*
* Now check for newly sent messages by the other side. (The remote
* PUT value will have changed since we last looked at it.)
@@ -1318,7 +1274,6 @@ xpc_process_msg_IPI(struct xpc_partition
xpc_msgqueue_deref(ch);
}

-
void
xpc_process_channel_activity(struct xpc_partition *part)
{
@@ -1328,7 +1283,6 @@ xpc_process_channel_activity(struct xpc_
int ch_number;
u32 ch_flags;

-
IPI_amo = xpc_get_IPI_flags(part);

/*
@@ -1341,7 +1295,6 @@ xpc_process_channel_activity(struct xpc_
for (ch_number = 0; ch_number < part->nchannels; ch_number++) {
ch = &part->channels[ch_number];

-
/*
* Process any open or close related IPI flags, and then deal
* with connecting or disconnecting the channel as required.
@@ -1369,7 +1322,7 @@ xpc_process_channel_activity(struct xpc_
if (!(ch_flags & XPC_C_CONNECTED)) {
if (!(ch_flags & XPC_C_OPENREQUEST)) {
DBUG_ON(ch_flags & XPC_C_SETUP);
- (void) xpc_connect_channel(ch);
+ (void)xpc_connect_channel(ch);
} else {
spin_lock_irqsave(&ch->lock, irq_flags);
xpc_process_connect(ch, &irq_flags);
@@ -1378,7 +1331,6 @@ xpc_process_channel_activity(struct xpc_
continue;
}

-
/*
* Process any message related IPI flags, this may involve the
* activation of kthreads to deliver any pending messages sent
@@ -1391,7 +1343,6 @@ xpc_process_channel_activity(struct xpc_
}
}

-
/*
* XPC's heartbeat code calls this function to inform XPC that a partition is
* going down. XPC responds by tearing down the XPartition Communication
@@ -1408,7 +1359,6 @@ xpc_partition_going_down(struct xpc_part
int ch_number;
struct xpc_channel *ch;

-
dev_dbg(xpc_chan, "deactivating partition %d, reason=%d\n",
XPC_PARTID(part), reason);

@@ -1417,7 +1367,6 @@ xpc_partition_going_down(struct xpc_part
return;
}

-
/* disconnect channels associated with the partition going down */

for (ch_number = 0; ch_number < part->nchannels; ch_number++) {
@@ -1437,7 +1386,6 @@ xpc_partition_going_down(struct xpc_part
xpc_part_deref(part);
}

-
/*
* Teardown the infrastructure necessary to support XPartition Communication
* between the specified remote partition and the local one.
@@ -1447,7 +1395,6 @@ xpc_teardown_infrastructure(struct xpc_p
{
short partid = XPC_PARTID(part);

-
/*
* We start off by making this partition inaccessible to local
* processes by marking it as no longer setup. Then we make it
@@ -1464,9 +1411,7 @@ xpc_teardown_infrastructure(struct xpc_p

xpc_vars_part[partid].magic = 0;

-
- free_irq(SGI_XPC_NOTIFY, (void *) (u64) partid);
-
+ free_irq(SGI_XPC_NOTIFY, (void *)(u64)partid);

/*
* Before proceeding with the teardown we have to wait until all
@@ -1474,7 +1419,6 @@ xpc_teardown_infrastructure(struct xpc_p
*/
wait_event(part->teardown_wq, (atomic_read(&part->references) == 0));

-
/* now we can begin tearing down the infrastructure */

part->setup_state = XPC_P_SS_TORNDOWN;
@@ -1495,7 +1439,6 @@ xpc_teardown_infrastructure(struct xpc_p
part->local_IPI_amo_va = NULL;
}

-
/*
* Called by XP at the time of channel connection registration to cause
* XPC to establish connections to all currently active partitions.
@@ -1507,7 +1450,6 @@ xpc_initiate_connect(int ch_number)
struct xpc_partition *part;
struct xpc_channel *ch;

-
DBUG_ON(ch_number < 0 || ch_number >= XPC_NCHANNELS);

for (partid = XP_MIN_PARTID; partid <= XP_MAX_PARTID; partid++) {
@@ -1526,7 +1468,6 @@ xpc_initiate_connect(int ch_number)
}
}

-
void
xpc_connected_callout(struct xpc_channel *ch)
{
@@ -1537,14 +1478,13 @@ xpc_connected_callout(struct xpc_channel
"partid=%d, channel=%d\n", ch->partid, ch->number);

ch->func(xpConnected, ch->partid, ch->number,
- (void *) (u64) ch->local_nentries, ch->key);
+ (void *)(u64)ch->local_nentries, ch->key);

dev_dbg(xpc_chan, "ch->func() returned, reason=xpConnected, "
"partid=%d, channel=%d\n", ch->partid, ch->number);
}
}

-
/*
* Called by XP at the time of channel connection unregistration to cause
* XPC to teardown all current connections for the specified channel.
@@ -1566,7 +1506,6 @@ xpc_initiate_disconnect(int ch_number)
struct xpc_partition *part;
struct xpc_channel *ch;

-
DBUG_ON(ch_number < 0 || ch_number >= XPC_NCHANNELS);

/* initiate the channel disconnect for every active partition */
@@ -1583,7 +1522,7 @@ xpc_initiate_disconnect(int ch_number)
ch->flags |= XPC_C_WDISCONNECT;

XPC_DISCONNECT_CHANNEL(ch, xpUnregistering,
- &irq_flags);
+ &irq_flags);
}

spin_unlock_irqrestore(&ch->lock, irq_flags);
@@ -1596,7 +1535,6 @@ xpc_initiate_disconnect(int ch_number)
xpc_disconnect_wait(ch_number);
}

-
/*
* To disconnect a channel, and reflect it back to all who may be waiting.
*
@@ -1608,11 +1546,10 @@ xpc_initiate_disconnect(int ch_number)
*/
void
xpc_disconnect_channel(const int line, struct xpc_channel *ch,
- enum xp_retval reason, unsigned long *irq_flags)
+ enum xp_retval reason, unsigned long *irq_flags)
{
u32 channel_was_connected = (ch->flags & XPC_C_CONNECTED);

-
DBUG_ON(!spin_is_locked(&ch->lock));

if (ch->flags & (XPC_C_DISCONNECTING | XPC_C_DISCONNECTED)) {
@@ -1628,8 +1565,8 @@ xpc_disconnect_channel(const int line, s
ch->flags |= (XPC_C_CLOSEREQUEST | XPC_C_DISCONNECTING);
/* some of these may not have been set */
ch->flags &= ~(XPC_C_OPENREQUEST | XPC_C_OPENREPLY |
- XPC_C_ROPENREQUEST | XPC_C_ROPENREPLY |
- XPC_C_CONNECTING | XPC_C_CONNECTED);
+ XPC_C_ROPENREQUEST | XPC_C_ROPENREPLY |
+ XPC_C_CONNECTING | XPC_C_CONNECTED);

xpc_IPI_send_closerequest(ch, irq_flags);

@@ -1644,7 +1581,7 @@ xpc_disconnect_channel(const int line, s
wake_up_all(&ch->idle_wq);

} else if ((ch->flags & XPC_C_CONNECTEDCALLOUT_MADE) &&
- !(ch->flags & XPC_C_DISCONNECTINGCALLOUT)) {
+ !(ch->flags & XPC_C_DISCONNECTINGCALLOUT)) {
/* start a kthread that will do the xpDisconnecting callout */
xpc_create_kthreads(ch, 1, 1);
}
@@ -1657,7 +1594,6 @@ xpc_disconnect_channel(const int line, s
spin_lock_irqsave(&ch->lock, *irq_flags);
}

-
void
xpc_disconnect_callout(struct xpc_channel *ch, enum xp_retval reason)
{
@@ -1678,7 +1614,6 @@ xpc_disconnect_callout(struct xpc_channe
}
}

-
/*
* Wait for a message entry to become available for the specified channel,
* but don't wait any longer than 1 jiffy.
@@ -1688,7 +1623,6 @@ xpc_allocate_msg_wait(struct xpc_channel
{
enum xp_retval ret;

-
if (ch->flags & XPC_C_DISCONNECTING) {
DBUG_ON(ch->reason == xpInterrupted);
return ch->reason;
@@ -1710,20 +1644,18 @@ xpc_allocate_msg_wait(struct xpc_channel
return ret;
}

-
/*
* Allocate an entry for a message from the message queue associated with the
* specified channel.
*/
static enum xp_retval
xpc_allocate_msg(struct xpc_channel *ch, u32 flags,
- struct xpc_msg **address_of_msg)
+ struct xpc_msg **address_of_msg)
{
struct xpc_msg *msg;
enum xp_retval ret;
s64 put;

-
/* this reference will be dropped in xpc_send_msg() */
xpc_msgqueue_ref(ch);

@@ -1736,7 +1668,6 @@ xpc_allocate_msg(struct xpc_channel *ch,
return xpNotConnected;
}

-
/*
* Get the next available message entry from the local message queue.
* If none are available, we'll make sure that we grab the latest
@@ -1746,25 +1677,23 @@ xpc_allocate_msg(struct xpc_channel *ch,

while (1) {

- put = (volatile s64) ch->w_local_GP.put;
- if (put - (volatile s64) ch->w_remote_GP.get <
- ch->local_nentries) {
+ put = (volatile s64)ch->w_local_GP.put;
+ if (put - (volatile s64)ch->w_remote_GP.get <
+ ch->local_nentries) {

/* There are available message entries. We need to try
* to secure one for ourselves. We'll do this by trying
* to increment w_local_GP.put as long as someone else
* doesn't beat us to it. If they do, we'll have to
* try again.
- */
- if (cmpxchg(&ch->w_local_GP.put, put, put + 1) ==
- put) {
+ */
+ if (cmpxchg(&ch->w_local_GP.put, put, put + 1) == put) {
/* we got the entry referenced by put */
break;
}
continue; /* try again */
}

-
/*
* There aren't any available msg entries at this time.
*
@@ -1790,25 +1719,22 @@ xpc_allocate_msg(struct xpc_channel *ch,
}
}

-
/* get the message's address and initialize it */
- msg = (struct xpc_msg *) ((u64) ch->local_msgqueue +
- (put % ch->local_nentries) * ch->msg_size);
-
+ msg = (struct xpc_msg *)((u64)ch->local_msgqueue +
+ (put % ch->local_nentries) * ch->msg_size);

DBUG_ON(msg->flags != 0);
msg->number = put;

dev_dbg(xpc_chan, "w_local_GP.put changed to %" U64_ELL "d; msg=0x%p, "
"msg_number=%" U64_ELL "d, partid=%d, channel=%d\n", put + 1,
- (void *) msg, msg->number, ch->partid, ch->number);
+ (void *)msg, msg->number, ch->partid, ch->number);

*address_of_msg = msg;

return xpSuccess;
}

-
/*
* Allocate an entry for a message from the message queue associated with the
* specified channel. NOTE that this routine can sleep waiting for a message
@@ -1829,7 +1755,6 @@ xpc_initiate_allocate(short partid, int
enum xp_retval ret = xpUnknownReason;
struct xpc_msg *msg = NULL;

-
DBUG_ON(partid < XP_MIN_PARTID || partid > XP_MAX_PARTID);
DBUG_ON(ch_number < 0 || ch_number >= part->nchannels);

@@ -1847,7 +1772,6 @@ xpc_initiate_allocate(short partid, int
return ret;
}

-
/*
* Now we actually send the messages that are ready to be sent by advancing
* the local message queue's Put value and then send an IPI to the recipient
@@ -1860,16 +1784,16 @@ xpc_send_msgs(struct xpc_channel *ch, s6
s64 put = initial_put + 1;
int send_IPI = 0;

-
while (1) {

while (1) {
- if (put == (volatile s64) ch->w_local_GP.put) {
+ if (put == (volatile s64)ch->w_local_GP.put) {
break;
}

- msg = (struct xpc_msg *) ((u64) ch->local_msgqueue +
- (put % ch->local_nentries) * ch->msg_size);
+ msg = (struct xpc_msg *)((u64)ch->local_msgqueue +
+ (put % ch->local_nentries) *
+ ch->msg_size);

if (!(msg->flags & XPC_M_READY)) {
break;
@@ -1884,9 +1808,9 @@ xpc_send_msgs(struct xpc_channel *ch, s6
}

if (cmpxchg_rel(&ch->local_GP->put, initial_put, put) !=
- initial_put) {
+ initial_put) {
/* someone else beat us to it */
- DBUG_ON((volatile s64) ch->local_GP->put < initial_put);
+ DBUG_ON((volatile s64)ch->local_GP->put < initial_put);
break;
}

@@ -1910,7 +1834,6 @@ xpc_send_msgs(struct xpc_channel *ch, s6
}
}

-
/*
* Common code that does the actual sending of the message by advancing the
* local message queue's Put value and sends an IPI to the partition the
@@ -1918,16 +1841,15 @@ xpc_send_msgs(struct xpc_channel *ch, s6
*/
static enum xp_retval
xpc_send_msg(struct xpc_channel *ch, struct xpc_msg *msg, u8 notify_type,
- xpc_notify_func func, void *key)
+ xpc_notify_func func, void *key)
{
enum xp_retval ret = xpSuccess;
struct xpc_notify *notify = notify;
s64 put, msg_number = msg->number;

-
DBUG_ON(notify_type == XPC_N_CALL && func == NULL);
- DBUG_ON((((u64) msg - (u64) ch->local_msgqueue) / ch->msg_size) !=
- msg_number % ch->local_nentries);
+ DBUG_ON((((u64)msg - (u64)ch->local_msgqueue) / ch->msg_size) !=
+ msg_number % ch->local_nentries);
DBUG_ON(msg->flags & XPC_M_READY);

if (ch->flags & XPC_C_DISCONNECTING) {
@@ -1961,7 +1883,7 @@ xpc_send_msg(struct xpc_channel *ch, str
* the notify entry.
*/
if (cmpxchg(&notify->type, notify_type, 0) ==
- notify_type) {
+ notify_type) {
atomic_dec(&ch->n_to_notify);
ret = ch->reason;
}
@@ -1992,7 +1914,6 @@ xpc_send_msg(struct xpc_channel *ch, str
return ret;
}

-
/*
* Send a message previously allocated using xpc_initiate_allocate() on the
* specified channel connected to the specified partition.
@@ -2020,8 +1941,7 @@ xpc_initiate_send(short partid, int ch_n
struct xpc_msg *msg = XPC_MSG_ADDRESS(payload);
enum xp_retval ret;

-
- dev_dbg(xpc_chan, "msg=0x%p, partid=%d, channel=%d\n", (void *) msg,
+ dev_dbg(xpc_chan, "msg=0x%p, partid=%d, channel=%d\n", (void *)msg,
partid, ch_number);

DBUG_ON(partid < XP_MIN_PARTID || partid > XP_MAX_PARTID);
@@ -2033,7 +1953,6 @@ xpc_initiate_send(short partid, int ch_n
return ret;
}

-
/*
* Send a message previously allocated using xpc_initiate_allocate on the
* specified channel connected to the specified partition.
@@ -2066,14 +1985,13 @@ xpc_initiate_send(short partid, int ch_n
*/
enum xp_retval
xpc_initiate_send_notify(short partid, int ch_number, void *payload,
- xpc_notify_func func, void *key)
+ xpc_notify_func func, void *key)
{
struct xpc_partition *part = &xpc_partitions[partid];
struct xpc_msg *msg = XPC_MSG_ADDRESS(payload);
enum xp_retval ret;

-
- dev_dbg(xpc_chan, "msg=0x%p, partid=%d, channel=%d\n", (void *) msg,
+ dev_dbg(xpc_chan, "msg=0x%p, partid=%d, channel=%d\n", (void *)msg,
partid, ch_number);

DBUG_ON(partid < XP_MIN_PARTID || partid > XP_MAX_PARTID);
@@ -2082,11 +2000,10 @@ xpc_initiate_send_notify(short partid, i
DBUG_ON(func == NULL);

ret = xpc_send_msg(&part->channels[ch_number], msg, XPC_N_CALL,
- func, key);
+ func, key);
return ret;
}

-
static struct xpc_msg *
xpc_pull_remote_msg(struct xpc_channel *ch, s64 get)
{
@@ -2096,7 +2013,6 @@ xpc_pull_remote_msg(struct xpc_channel *
u64 msg_offset;
enum xp_retval ret;

-
if (mutex_lock_interruptible(&ch->msg_to_pull_mutex) != 0) {
/* we were interrupted by a signal */
return NULL;
@@ -2109,22 +2025,22 @@ xpc_pull_remote_msg(struct xpc_channel *
msg_index = ch->next_msg_to_pull % ch->remote_nentries;

DBUG_ON(ch->next_msg_to_pull >=
- (volatile s64) ch->w_remote_GP.put);
- nmsgs = (volatile s64) ch->w_remote_GP.put -
- ch->next_msg_to_pull;
+ (volatile s64)ch->w_remote_GP.put);
+ nmsgs = (volatile s64)ch->w_remote_GP.put -
+ ch->next_msg_to_pull;
if (msg_index + nmsgs > ch->remote_nentries) {
/* ignore the ones that wrap the msg queue for now */
nmsgs = ch->remote_nentries - msg_index;
}

msg_offset = msg_index * ch->msg_size;
- msg = (struct xpc_msg *) ((u64) ch->remote_msgqueue +
- msg_offset);
- remote_msg = (struct xpc_msg *) (ch->remote_msgqueue_pa +
- msg_offset);
+ msg = (struct xpc_msg *)((u64)ch->remote_msgqueue + msg_offset);
+ remote_msg = (struct xpc_msg *)(ch->remote_msgqueue_pa +
+ msg_offset);

if ((ret = xpc_pull_remote_cachelines(part, msg, remote_msg,
- nmsgs * ch->msg_size)) != xpSuccess) {
+ nmsgs * ch->msg_size)) !=
+ xpSuccess) {

dev_dbg(xpc_chan, "failed to pull %d msgs starting with"
" msg %" U64_ELL "d from partition %d, "
@@ -2138,7 +2054,7 @@ xpc_pull_remote_msg(struct xpc_channel *
return NULL;
}

- mb(); /* >>> this may not be needed, we're not sure */
+ mb(); /* >>> this may not be needed, we're not sure */

ch->next_msg_to_pull += nmsgs;
}
@@ -2147,12 +2063,11 @@ xpc_pull_remote_msg(struct xpc_channel *

/* return the message we were looking for */
msg_offset = (get % ch->remote_nentries) * ch->msg_size;
- msg = (struct xpc_msg *) ((u64) ch->remote_msgqueue + msg_offset);
+ msg = (struct xpc_msg *)((u64)ch->remote_msgqueue + msg_offset);

return msg;
}

-
/*
* Get a message to be delivered.
*/
@@ -2162,14 +2077,13 @@ xpc_get_deliverable_msg(struct xpc_chann
struct xpc_msg *msg = NULL;
s64 get;

-
do {
- if ((volatile u32) ch->flags & XPC_C_DISCONNECTING) {
+ if ((volatile u32)ch->flags & XPC_C_DISCONNECTING) {
break;
}

- get = (volatile s64) ch->w_local_GP.get;
- if (get == (volatile s64) ch->w_remote_GP.put) {
+ get = (volatile s64)ch->w_local_GP.get;
+ if (get == (volatile s64)ch->w_remote_GP.put) {
break;
}

@@ -2178,7 +2092,7 @@ xpc_get_deliverable_msg(struct xpc_chann
* by trying to increment w_local_GP.get and hope that no one
* else beats us to it. If they do, we'll we'll simply have
* to try again for the next one.
- */
+ */

if (cmpxchg(&ch->w_local_GP.get, get, get + 1) == get) {
/* we got the entry referenced by get */
@@ -2203,7 +2117,6 @@ xpc_get_deliverable_msg(struct xpc_chann
return msg;
}

-
/*
* Deliver a message to its intended recipient.
*/
@@ -2212,7 +2125,6 @@ xpc_deliver_msg(struct xpc_channel *ch)
{
struct xpc_msg *msg;

-
if ((msg = xpc_get_deliverable_msg(ch)) != NULL) {

/*
@@ -2227,16 +2139,16 @@ xpc_deliver_msg(struct xpc_channel *ch)
if (ch->func != NULL) {
dev_dbg(xpc_chan, "ch->func() called, msg=0x%p, "
"msg_number=%" U64_ELL "d, partid=%d, "
- "channel=%d\n", (void *) msg, msg->number,
+ "channel=%d\n", (void *)msg, msg->number,
ch->partid, ch->number);

/* deliver the message to its intended recipient */
ch->func(xpMsgReceived, ch->partid, ch->number,
- &msg->payload, ch->key);
+ &msg->payload, ch->key);

dev_dbg(xpc_chan, "ch->func() returned, msg=0x%p, "
"msg_number=%" U64_ELL "d, partid=%d, "
- "channel=%d\n", (void *) msg, msg->number,
+ "channel=%d\n", (void *)msg, msg->number,
ch->partid, ch->number);
}

@@ -2244,7 +2156,6 @@ xpc_deliver_msg(struct xpc_channel *ch)
}
}

-
/*
* Now we actually acknowledge the messages that have been delivered and ack'd
* by advancing the cached remote message queue's Get value and if requested
@@ -2257,16 +2168,16 @@ xpc_acknowledge_msgs(struct xpc_channel
s64 get = initial_get + 1;
int send_IPI = 0;

-
while (1) {

while (1) {
- if (get == (volatile s64) ch->w_local_GP.get) {
+ if (get == (volatile s64)ch->w_local_GP.get) {
break;
}

- msg = (struct xpc_msg *) ((u64) ch->remote_msgqueue +
- (get % ch->remote_nentries) * ch->msg_size);
+ msg = (struct xpc_msg *)((u64)ch->remote_msgqueue +
+ (get % ch->remote_nentries) *
+ ch->msg_size);

if (!(msg->flags & XPC_M_DONE)) {
break;
@@ -2282,10 +2193,9 @@ xpc_acknowledge_msgs(struct xpc_channel
}

if (cmpxchg_rel(&ch->local_GP->get, initial_get, get) !=
- initial_get) {
+ initial_get) {
/* someone else beat us to it */
- DBUG_ON((volatile s64) ch->local_GP->get <=
- initial_get);
+ DBUG_ON((volatile s64)ch->local_GP->get <= initial_get);
break;
}

@@ -2309,7 +2219,6 @@ xpc_acknowledge_msgs(struct xpc_channel
}
}

-
/*
* Acknowledge receipt of a delivered message.
*
@@ -2335,18 +2244,17 @@ xpc_initiate_received(short partid, int
struct xpc_msg *msg = XPC_MSG_ADDRESS(payload);
s64 get, msg_number = msg->number;

-
DBUG_ON(partid < XP_MIN_PARTID || partid > XP_MAX_PARTID);
DBUG_ON(ch_number < 0 || ch_number >= part->nchannels);

ch = &part->channels[ch_number];

dev_dbg(xpc_chan, "msg=0x%p, msg_number=%" U64_ELL "d, partid=%d, "
- "channel=%d\n", (void *) msg, msg_number, ch->partid,
+ "channel=%d\n", (void *)msg, msg_number, ch->partid,
ch->number);

- DBUG_ON((((u64) msg - (u64) ch->remote_msgqueue) / ch->msg_size) !=
- msg_number % ch->remote_nentries);
+ DBUG_ON((((u64)msg - (u64)ch->remote_msgqueue) / ch->msg_size) !=
+ msg_number % ch->remote_nentries);
DBUG_ON(msg->flags & XPC_M_DONE);

msg->flags |= XPC_M_DONE;
@@ -2369,4 +2277,3 @@ xpc_initiate_received(short partid, int
/* the call to xpc_msgqueue_ref() was done by xpc_deliver_msg() */
xpc_msgqueue_deref(ch);
}
-
Index: linux-2.6/drivers/misc/xp/xpc_main.c
===================================================================
--- linux-2.6.orig/drivers/misc/xp/xpc_main.c 2008-03-21 13:30:52.034175000 -0500
+++ linux-2.6/drivers/misc/xp/xpc_main.c 2008-03-24 19:31:37.154185684 -0500
@@ -6,7 +6,6 @@
* Copyright (c) 2004-2008 Silicon Graphics, Inc. All Rights Reserved.
*/

-
/*
* Cross Partition Communication (XPC) support - standard version.
*
@@ -44,7 +43,6 @@
*
*/

-
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
@@ -67,7 +65,6 @@
#include <asm/uaccess.h>
#include "xpc.h"

-
/* define two XPC debug device structures to be used with dev_dbg() et al */

struct device_driver xpc_dbg_name = {
@@ -87,10 +84,8 @@ struct device xpc_chan_dbg_subname = {
struct device *xpc_part = &xpc_part_dbg_subname;
struct device *xpc_chan = &xpc_chan_dbg_subname;

-
static int xpc_kdebug_ignore;

-
/* systune related variables for /proc/sys directories */

static int xpc_hb_interval = XPC_HB_DEFAULT_INTERVAL;
@@ -107,56 +102,51 @@ static int xpc_disengage_request_max_tim

static ctl_table xpc_sys_xpc_hb_dir[] = {
{
- .ctl_name = CTL_UNNUMBERED,
- .procname = "hb_interval",
- .data = &xpc_hb_interval,
- .maxlen = sizeof(int),
- .mode = 0644,
- .proc_handler = &proc_dointvec_minmax,
- .strategy = &sysctl_intvec,
- .extra1 = &xpc_hb_min_interval,
- .extra2 = &xpc_hb_max_interval
- },
+ .ctl_name = CTL_UNNUMBERED,
+ .procname = "hb_interval",
+ .data = &xpc_hb_interval,
+ .maxlen = sizeof(int),
+ .mode = 0644,
+ .proc_handler = &proc_dointvec_minmax,
+ .strategy = &sysctl_intvec,
+ .extra1 = &xpc_hb_min_interval,
+ .extra2 = &xpc_hb_max_interval},
{
- .ctl_name = CTL_UNNUMBERED,
- .procname = "hb_check_interval",
- .data = &xpc_hb_check_interval,
- .maxlen = sizeof(int),
- .mode = 0644,
- .proc_handler = &proc_dointvec_minmax,
- .strategy = &sysctl_intvec,
- .extra1 = &xpc_hb_check_min_interval,
- .extra2 = &xpc_hb_check_max_interval
- },
+ .ctl_name = CTL_UNNUMBERED,
+ .procname = "hb_check_interval",
+ .data = &xpc_hb_check_interval,
+ .maxlen = sizeof(int),
+ .mode = 0644,
+ .proc_handler = &proc_dointvec_minmax,
+ .strategy = &sysctl_intvec,
+ .extra1 = &xpc_hb_check_min_interval,
+ .extra2 = &xpc_hb_check_max_interval},
{}
};
static ctl_table xpc_sys_xpc_dir[] = {
{
- .ctl_name = CTL_UNNUMBERED,
- .procname = "hb",
- .mode = 0555,
- .child = xpc_sys_xpc_hb_dir
- },
+ .ctl_name = CTL_UNNUMBERED,
+ .procname = "hb",
+ .mode = 0555,
+ .child = xpc_sys_xpc_hb_dir},
{
- .ctl_name = CTL_UNNUMBERED,
- .procname = "disengage_request_timelimit",
- .data = &xpc_disengage_request_timelimit,
- .maxlen = sizeof(int),
- .mode = 0644,
- .proc_handler = &proc_dointvec_minmax,
- .strategy = &sysctl_intvec,
- .extra1 = &xpc_disengage_request_min_timelimit,
- .extra2 = &xpc_disengage_request_max_timelimit
- },
+ .ctl_name = CTL_UNNUMBERED,
+ .procname = "disengage_request_timelimit",
+ .data = &xpc_disengage_request_timelimit,
+ .maxlen = sizeof(int),
+ .mode = 0644,
+ .proc_handler = &proc_dointvec_minmax,
+ .strategy = &sysctl_intvec,
+ .extra1 = &xpc_disengage_request_min_timelimit,
+ .extra2 = &xpc_disengage_request_max_timelimit},
{}
};
static ctl_table xpc_sys_dir[] = {
{
- .ctl_name = CTL_UNNUMBERED,
- .procname = "xpc",
- .mode = 0555,
- .child = xpc_sys_xpc_dir
- },
+ .ctl_name = CTL_UNNUMBERED,
+ .procname = "xpc",
+ .mode = 0555,
+ .child = xpc_sys_xpc_dir},
{}
};
static struct ctl_table_header *xpc_sysctl;
@@ -178,13 +168,10 @@ static DECLARE_COMPLETION(xpc_hb_checker
/* notification that the xpc_discovery thread has exited */
static DECLARE_COMPLETION(xpc_discovery_exited);

-
static struct timer_list xpc_hb_timer;

-
static void xpc_kthread_waitmsgs(struct xpc_partition *, struct xpc_channel *);

-
static int xpc_system_reboot(struct notifier_block *, unsigned long, void *);
static struct notifier_block xpc_reboot_notifier = {
.notifier_call = xpc_system_reboot,
@@ -195,25 +182,22 @@ static struct notifier_block xpc_die_not
.notifier_call = xpc_system_die,
};

-
/*
* Timer function to enforce the timelimit on the partition disengage request.
*/
static void
xpc_timeout_partition_disengage_request(unsigned long data)
{
- struct xpc_partition *part = (struct xpc_partition *) data;
-
+ struct xpc_partition *part = (struct xpc_partition *)data;

DBUG_ON(jiffies < part->disengage_request_timeout);

- (void) xpc_partition_disengaged(part);
+ (void)xpc_partition_disengaged(part);

DBUG_ON(part->disengage_request_timeout != 0);
DBUG_ON(xpc_partition_engaged(XPC_PARTID(part)) != 0);
}

-
/*
* Notify the heartbeat check thread that an IRQ has been received.
*/
@@ -225,7 +209,6 @@ xpc_act_IRQ_handler(int irq, void *dev_i
return IRQ_HANDLED;
}

-
/*
* Timer to produce the heartbeat. The timer structures function is
* already set when this is initially called. A tunable is used to
@@ -244,7 +227,6 @@ xpc_hb_beater(unsigned long dummy)
add_timer(&xpc_hb_timer);
}

-
/*
* This thread is responsible for nearly all of the partition
* activation/deactivation.
@@ -254,8 +236,7 @@ xpc_hb_checker(void *ignore)
{
int last_IRQ_count = 0;
int new_IRQ_count;
- int force_IRQ=0;
-
+ int force_IRQ = 0;

/* this thread was marked active by xpc_hb_init() */

@@ -267,14 +248,13 @@ xpc_hb_checker(void *ignore)
xpc_hb_check_timeout = jiffies + (xpc_hb_check_interval * HZ);
xpc_hb_beater(0);

- while (!(volatile int) xpc_exiting) {
+ while (!(volatile int)xpc_exiting) {

dev_dbg(xpc_part, "woke up with %d ticks rem; %d IRQs have "
"been received\n",
- (int) (xpc_hb_check_timeout - jiffies),
+ (int)(xpc_hb_check_timeout - jiffies),
atomic_read(&xpc_act_IRQ_rcvd) - last_IRQ_count);

-
/* checking of remote heartbeats is skewed by IRQ handling */
if (jiffies >= xpc_hb_check_timeout) {
dev_dbg(xpc_part, "checking remote heartbeats\n");
@@ -288,7 +268,6 @@ xpc_hb_checker(void *ignore)
force_IRQ = 1;
}

-
/* check for outstanding IRQs */
new_IRQ_count = atomic_read(&xpc_act_IRQ_rcvd);
if (last_IRQ_count < new_IRQ_count || force_IRQ != 0) {
@@ -300,30 +279,30 @@ xpc_hb_checker(void *ignore)
last_IRQ_count += xpc_identify_act_IRQ_sender();
if (last_IRQ_count < new_IRQ_count) {
/* retry once to help avoid missing AMO */
- (void) xpc_identify_act_IRQ_sender();
+ (void)xpc_identify_act_IRQ_sender();
}
last_IRQ_count = new_IRQ_count;

xpc_hb_check_timeout = jiffies +
- (xpc_hb_check_interval * HZ);
+ (xpc_hb_check_interval * HZ);
}

/* wait for IRQ or timeout */
- (void) wait_event_interruptible(xpc_act_IRQ_wq,
- (last_IRQ_count < atomic_read(&xpc_act_IRQ_rcvd) ||
- jiffies >= xpc_hb_check_timeout ||
- (volatile int) xpc_exiting));
+ (void)wait_event_interruptible(xpc_act_IRQ_wq,
+ (last_IRQ_count <
+ atomic_read(&xpc_act_IRQ_rcvd)
+ || jiffies >=
+ xpc_hb_check_timeout
+ || (volatile int)xpc_exiting));
}

dev_dbg(xpc_part, "heartbeat checker is exiting\n");

-
/* mark this thread as having exited */
complete(&xpc_hb_checker_exited);
return 0;
}

-
/*
* This thread will attempt to discover other partitions to activate
* based on info provided by SAL. This new thread is short lived and
@@ -343,7 +322,6 @@ xpc_initiate_discovery(void *ignore)
return 0;
}

-
/*
* Establish first contact with the remote partititon. This involves pulling
* the XPC per partition variables from the remote partition and waiting for
@@ -354,7 +332,6 @@ xpc_make_first_contact(struct xpc_partit
{
enum xp_retval ret;

-
while ((ret = xpc_pull_remote_vars_part(part)) != xpSuccess) {
if (ret != xpRetry) {
XPC_DEACTIVATE_PARTITION(part, ret);
@@ -365,7 +342,7 @@ xpc_make_first_contact(struct xpc_partit
"partition %d\n", XPC_PARTID(part));

/* wait a 1/4 of a second or so */
- (void) msleep_interruptible(250);
+ (void)msleep_interruptible(250);

if (part->act_state == XPC_P_AS_DEACTIVATING) {
return part->reason;
@@ -375,7 +352,6 @@ xpc_make_first_contact(struct xpc_partit
return xpc_mark_partition_active(part);
}

-
/*
* The first kthread assigned to a newly activated partition is the one
* created by XPC HB with which it calls xpc_partition_up(). XPC hangs on to
@@ -392,12 +368,11 @@ static void
xpc_channel_mgr(struct xpc_partition *part)
{
while (part->act_state != XPC_P_AS_DEACTIVATING ||
- atomic_read(&part->nchannels_active) > 0 ||
- !xpc_partition_disengaged(part)) {
+ atomic_read(&part->nchannels_active) > 0 ||
+ !xpc_partition_disengaged(part)) {

xpc_process_channel_activity(part);

-
/*
* Wait until we've been requested to activate kthreads or
* all of the channel's message queues have been torn down or
@@ -412,18 +387,25 @@ xpc_channel_mgr(struct xpc_partition *pa
* wake him up.
*/
atomic_dec(&part->channel_mgr_requests);
- (void) wait_event_interruptible(part->channel_mgr_wq,
- (atomic_read(&part->channel_mgr_requests) > 0 ||
- (volatile u64) part->local_IPI_amo != 0 ||
- ((volatile u8) part->act_state ==
- XPC_P_AS_DEACTIVATING &&
- atomic_read(&part->nchannels_active) == 0 &&
- xpc_partition_disengaged(part))));
+ (void)wait_event_interruptible(part->channel_mgr_wq,
+ (atomic_read
+ (&part->channel_mgr_requests) >
+ 0
+ || (volatile u64)part->
+ local_IPI_amo != 0
+ || ((volatile u8)part->
+ act_state ==
+ XPC_P_AS_DEACTIVATING
+ && atomic_read(&part->
+ nchannels_active)
+ == 0
+ &&
+ xpc_partition_disengaged
+ (part))));
atomic_set(&part->channel_mgr_requests, 1);
}
}

-
/*
* When XPC HB determines that a partition has come up, it will create a new
* kthread and that kthread will call this function to attempt to set up the
@@ -457,7 +439,7 @@ xpc_partition_up(struct xpc_partition *p
* has been dismantled.
*/

- (void) xpc_part_ref(part); /* this will always succeed */
+ (void)xpc_part_ref(part); /* this will always succeed */

if (xpc_make_first_contact(part) == xpSuccess) {
xpc_channel_mgr(part);
@@ -468,17 +450,15 @@ xpc_partition_up(struct xpc_partition *p
xpc_teardown_infrastructure(part);
}

-
static int
xpc_activating(void *__partid)
{
- short partid = (u64) __partid;
+ short partid = (u64)__partid;
struct xpc_partition *part = &xpc_partitions[partid];
unsigned long irq_flags;
- struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 };
+ struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1 };
int ret;

-
DBUG_ON(partid < XP_MIN_PARTID || partid > XP_MAX_PARTID);

spin_lock_irqsave(&part->lock, irq_flags);
@@ -508,7 +488,7 @@ xpc_activating(void *__partid)
ret = sched_setscheduler(current, SCHED_FIFO, &param);
if (ret != 0) {
dev_warn(xpc_part, "unable to set pid %d to a realtime "
- "priority, ret=%d\n", current->pid, ret);
+ "priority, ret=%d\n", current->pid, ret);
}

/* allow this thread and its children to run on any CPU */
@@ -522,8 +502,7 @@ xpc_activating(void *__partid)
ret = xpc_register_remote_amos(part);
if (ret != xpSuccess) {
dev_warn(xpc_part, "xpc_activating() failed to register remote "
- "AMOs for partition %d, ret=%d\n", partid,
- ret);
+ "AMOs for partition %d, ret=%d\n", partid, ret);

spin_lock_irqsave(&part->lock, irq_flags);
part->act_state = XPC_P_AS_INACTIVE;
@@ -536,7 +515,6 @@ xpc_activating(void *__partid)
xpc_allow_hb(partid, xpc_vars);
xpc_IPI_send_activated(part);

-
/*
* xpc_partition_up() holds this thread and marks this partition as
* XPC_P_AS_ACTIVE by calling xpc_hb_mark_active().
@@ -556,7 +534,6 @@ xpc_activating(void *__partid)
return 0;
}

-
void
xpc_activate_partition(struct xpc_partition *part)
{
@@ -564,7 +541,6 @@ xpc_activate_partition(struct xpc_partit
unsigned long irq_flags;
pid_t pid;

-
spin_lock_irqsave(&part->lock, irq_flags);

DBUG_ON(part->act_state != XPC_P_AS_INACTIVE);
@@ -574,7 +550,7 @@ xpc_activate_partition(struct xpc_partit

spin_unlock_irqrestore(&part->lock, irq_flags);

- pid = kernel_thread(xpc_activating, (void *) ((u64) partid), 0);
+ pid = kernel_thread(xpc_activating, (void *)((u64)partid), 0);

if (unlikely(pid <= 0)) {
spin_lock_irqsave(&part->lock, irq_flags);
@@ -584,7 +560,6 @@ xpc_activate_partition(struct xpc_partit
}
}

-
/*
* Handle the receipt of a SGI_XPC_NOTIFY IRQ by seeing whether the specified
* partition actually sent it. Since SGI_XPC_NOTIFY IRQs may be shared by more
@@ -604,10 +579,9 @@ xpc_activate_partition(struct xpc_partit
irqreturn_t
xpc_notify_IRQ_handler(int irq, void *dev_id)
{
- short partid = (short) (u64) dev_id;
+ short partid = (short)(u64)dev_id;
struct xpc_partition *part = &xpc_partitions[partid];

-
DBUG_ON(partid < XP_MIN_PARTID || partid > XP_MAX_PARTID);

if (xpc_part_ref(part)) {
@@ -618,7 +592,6 @@ xpc_notify_IRQ_handler(int irq, void *de
return IRQ_HANDLED;
}

-
/*
* Check to see if xpc_notify_IRQ_handler() dropped any IPIs on the floor
* because the write to their associated IPI amo completed after the IRQ/IPI
@@ -631,13 +604,12 @@ xpc_dropped_IPI_check(struct xpc_partiti
xpc_check_for_channel_activity(part);

part->dropped_IPI_timer.expires = jiffies +
- XPC_DROPPED_IPI_WAIT_INTERVAL;
+ XPC_DROPPED_IPI_WAIT_INTERVAL;
add_timer(&part->dropped_IPI_timer);
xpc_part_deref(part);
}
}

-
void
xpc_activate_kthreads(struct xpc_channel *ch, int needed)
{
@@ -645,7 +617,6 @@ xpc_activate_kthreads(struct xpc_channel
int assigned = atomic_read(&ch->kthreads_assigned);
int wakeup;

-
DBUG_ON(needed <= 0);

if (idle > 0) {
@@ -676,7 +647,6 @@ xpc_activate_kthreads(struct xpc_channel
xpc_create_kthreads(ch, needed, 0);
}

-
/*
* This function is where XPC's kthreads wait for messages to deliver.
*/
@@ -686,15 +656,14 @@ xpc_kthread_waitmsgs(struct xpc_partitio
do {
/* deliver messages to their intended recipients */

- while ((volatile s64) ch->w_local_GP.get <
- (volatile s64) ch->w_remote_GP.put &&
- !((volatile u32) ch->flags &
- XPC_C_DISCONNECTING)) {
+ while ((volatile s64)ch->w_local_GP.get <
+ (volatile s64)ch->w_remote_GP.put &&
+ !((volatile u32)ch->flags & XPC_C_DISCONNECTING)) {
xpc_deliver_msg(ch);
}

if (atomic_inc_return(&ch->kthreads_idle) >
- ch->kthreads_idle_limit) {
+ ch->kthreads_idle_limit) {
/* too many idle kthreads on this channel */
atomic_dec(&ch->kthreads_idle);
break;
@@ -703,18 +672,20 @@ xpc_kthread_waitmsgs(struct xpc_partitio
dev_dbg(xpc_chan, "idle kthread calling "
"wait_event_interruptible_exclusive()\n");

- (void) wait_event_interruptible_exclusive(ch->idle_wq,
- ((volatile s64) ch->w_local_GP.get <
- (volatile s64) ch->w_remote_GP.put ||
- ((volatile u32) ch->flags &
- XPC_C_DISCONNECTING)));
+ (void)wait_event_interruptible_exclusive(ch->idle_wq,
+ ((volatile s64)ch->
+ w_local_GP.get <
+ (volatile s64)ch->
+ w_remote_GP.put
+ || ((volatile u32)ch->
+ flags &
+ XPC_C_DISCONNECTING)));

atomic_dec(&ch->kthreads_idle);

- } while (!((volatile u32) ch->flags & XPC_C_DISCONNECTING));
+ } while (!((volatile u32)ch->flags & XPC_C_DISCONNECTING));
}

-
static int
xpc_daemonize_kthread(void *args)
{
@@ -725,7 +696,6 @@ xpc_daemonize_kthread(void *args)
int n_needed;
unsigned long irq_flags;

-
daemonize("xpc%02dc%d", partid, ch_number);

dev_dbg(xpc_chan, "kthread starting, partid=%d, channel=%d\n",
@@ -756,8 +726,7 @@ xpc_daemonize_kthread(void *args)
* need one less than total #of messages to deliver.
*/
n_needed = ch->w_remote_GP.put - ch->w_local_GP.get - 1;
- if (n_needed > 0 &&
- !(ch->flags & XPC_C_DISCONNECTING)) {
+ if (n_needed > 0 && !(ch->flags & XPC_C_DISCONNECTING)) {
xpc_activate_kthreads(ch, n_needed);
}
} else {
@@ -771,7 +740,7 @@ xpc_daemonize_kthread(void *args)

spin_lock_irqsave(&ch->lock, irq_flags);
if ((ch->flags & XPC_C_CONNECTEDCALLOUT_MADE) &&
- !(ch->flags & XPC_C_DISCONNECTINGCALLOUT)) {
+ !(ch->flags & XPC_C_DISCONNECTINGCALLOUT)) {
ch->flags |= XPC_C_DISCONNECTINGCALLOUT;
spin_unlock_irqrestore(&ch->lock, irq_flags);

@@ -798,7 +767,6 @@ xpc_daemonize_kthread(void *args)
return 0;
}

-
/*
* For each partition that XPC has established communications with, there is
* a minimum of one kernel thread assigned to perform any operation that
@@ -813,14 +781,13 @@ xpc_daemonize_kthread(void *args)
*/
void
xpc_create_kthreads(struct xpc_channel *ch, int needed,
- int ignore_disconnecting)
+ int ignore_disconnecting)
{
unsigned long irq_flags;
pid_t pid;
u64 args = XPC_PACK_ARGS(ch->partid, ch->number);
struct xpc_partition *part = &xpc_partitions[ch->partid];

-
while (needed-- > 0) {

/*
@@ -832,7 +799,7 @@ xpc_create_kthreads(struct xpc_channel *
if (!atomic_inc_not_zero(&ch->kthreads_assigned)) {
/* kthreads assigned had gone to zero */
BUG_ON(!(ch->flags &
- XPC_C_DISCONNECTINGCALLOUT_MADE));
+ XPC_C_DISCONNECTINGCALLOUT_MADE));
break;
}

@@ -843,10 +810,10 @@ xpc_create_kthreads(struct xpc_channel *
if (atomic_inc_return(&part->nchannels_engaged) == 1)
xpc_mark_partition_engaged(part);
}
- (void) xpc_part_ref(part);
+ (void)xpc_part_ref(part);
xpc_msgqueue_ref(ch);

- pid = kernel_thread(xpc_daemonize_kthread, (void *) args, 0);
+ pid = kernel_thread(xpc_daemonize_kthread, (void *)args, 0);
if (pid < 0) {
/* the fork failed */

@@ -869,7 +836,7 @@ xpc_create_kthreads(struct xpc_channel *
xpc_part_deref(part);

if (atomic_read(&ch->kthreads_assigned) <
- ch->kthreads_idle_limit) {
+ ch->kthreads_idle_limit) {
/*
* Flag this as an error only if we have an
* insufficient #of kthreads for the channel
@@ -877,7 +844,7 @@ xpc_create_kthreads(struct xpc_channel *
*/
spin_lock_irqsave(&ch->lock, irq_flags);
XPC_DISCONNECT_CHANNEL(ch, xpLackOfResources,
- &irq_flags);
+ &irq_flags);
spin_unlock_irqrestore(&ch->lock, irq_flags);
}
break;
@@ -885,7 +852,6 @@ xpc_create_kthreads(struct xpc_channel *
}
}

-
void
xpc_disconnect_wait(int ch_number)
{
@@ -895,7 +861,6 @@ xpc_disconnect_wait(int ch_number)
struct xpc_channel *ch;
int wakeup_channel_mgr;

-
/* now wait for all callouts to the caller's function to cease */
for (partid = XP_MIN_PARTID; partid <= XP_MAX_PARTID; partid++) {
part = &xpc_partitions[partid];
@@ -921,7 +886,8 @@ xpc_disconnect_wait(int ch_number)
if (part->act_state != XPC_P_AS_DEACTIVATING) {
spin_lock(&part->IPI_lock);
XPC_SET_IPI_FLAGS(part->local_IPI_amo,
- ch->number, ch->delayed_IPI_flags);
+ ch->number,
+ ch->delayed_IPI_flags);
spin_unlock(&part->IPI_lock);
wakeup_channel_mgr = 1;
}
@@ -939,7 +905,6 @@ xpc_disconnect_wait(int ch_number)
}
}

-
static void
xpc_do_exit(enum xp_retval reason)
{
@@ -948,7 +913,6 @@ xpc_do_exit(enum xp_retval reason)
struct xpc_partition *part;
unsigned long printmsg_time, disengage_request_timeout = 0;

-
/* a 'rmmod XPC' and a 'reboot' cannot both end up here together */
DBUG_ON(xpc_exiting == 1);

@@ -969,10 +933,8 @@ xpc_do_exit(enum xp_retval reason)
/* wait for the heartbeat checker thread to exit */
wait_for_completion(&xpc_hb_checker_exited);

-
/* sleep for a 1/3 of a second or so */
- (void) msleep_interruptible(300);
-
+ (void)msleep_interruptible(300);

/* wait for all partitions to become inactive */

@@ -982,12 +944,11 @@ xpc_do_exit(enum xp_retval reason)
do {
active_part_count = 0;

- for (partid = XP_MIN_PARTID; partid <= XP_MAX_PARTID;
- partid++) {
+ for (partid = XP_MIN_PARTID; partid <= XP_MAX_PARTID; partid++) {
part = &xpc_partitions[partid];

if (xpc_partition_disengaged(part) &&
- part->act_state == XPC_P_AS_INACTIVE) {
+ part->act_state == XPC_P_AS_INACTIVE) {
xpc_unregister_remote_amos(part);
continue;
}
@@ -997,47 +958,46 @@ xpc_do_exit(enum xp_retval reason)
XPC_DEACTIVATE_PARTITION(part, reason);

if (part->disengage_request_timeout >
- disengage_request_timeout) {
+ disengage_request_timeout) {
disengage_request_timeout =
- part->disengage_request_timeout;
+ part->disengage_request_timeout;
}
}

if (xpc_any_partition_engaged()) {
if (time_after(jiffies, printmsg_time)) {
dev_info(xpc_part, "waiting for remote "
- "partitions to disengage, timeout in "
- "%ld seconds\n",
- (disengage_request_timeout - jiffies)
- / HZ);
+ "partitions to disengage, timeout in "
+ "%ld seconds\n",
+ (disengage_request_timeout - jiffies)
+ / HZ);
printmsg_time = jiffies +
- (XPC_DISENGAGE_PRINTMSG_INTERVAL * HZ);
+ (XPC_DISENGAGE_PRINTMSG_INTERVAL * HZ);
printed_waiting_msg = 1;
}

} else if (active_part_count > 0) {
if (printed_waiting_msg) {
dev_info(xpc_part, "waiting for local partition"
- " to disengage\n");
+ " to disengage\n");
printed_waiting_msg = 0;
}

} else {
if (!xpc_disengage_request_timedout) {
dev_info(xpc_part, "all partitions have "
- "disengaged\n");
+ "disengaged\n");
}
break;
}

/* sleep for a 1/3 of a second or so */
- (void) msleep_interruptible(300);
+ (void)msleep_interruptible(300);

} while (1);

DBUG_ON(xpc_any_partition_engaged());

-
/* indicate to others that our reserved page is uninitialized */
xpc_rsvd_page->vars_pa = 0;

@@ -1047,17 +1007,16 @@ xpc_do_exit(enum xp_retval reason)

if (reason == xpUnloading) {
/* take ourselves off of the reboot_notifier_list */
- (void) unregister_reboot_notifier(&xpc_reboot_notifier);
+ (void)unregister_reboot_notifier(&xpc_reboot_notifier);

/* take ourselves off of the die_notifier list */
- (void) unregister_die_notifier(&xpc_die_notifier);
+ (void)unregister_die_notifier(&xpc_die_notifier);
}

/* close down protections for IPI operations */
xp_disallow_IPI_ops();
xp_change_memprotect_shub_wars_1_1(XP_MEMPROT_DISALLOW_ALL);

-
/* clear the interface to XPC's functions */
xpc_clear_interface();

@@ -1068,7 +1027,6 @@ xpc_do_exit(enum xp_retval reason)
kfree(xpc_remote_copy_buffer_base);
}

-
/*
* This function is called when the system is being rebooted.
*/
@@ -1077,7 +1035,6 @@ xpc_system_reboot(struct notifier_block
{
enum xp_retval reason;

-
switch (event) {
case SYS_RESTART:
reason = xpSystemReboot;
@@ -1096,7 +1053,6 @@ xpc_system_reboot(struct notifier_block
return NOTIFY_DONE;
}

-
#ifdef CONFIG_IA64
/*
* Notify other partitions to disengage from all references to our memory.
@@ -1108,17 +1064,15 @@ xpc_die_disengage(void)
short partid;
long time, printmsg_time, disengage_request_timeout;

-
/* keep xpc_hb_checker thread from doing anything (just in case) */
xpc_exiting = 1;

- xpc_disallow_all_hbs(xpc_vars); /* indicate we're deactivated */
+ xpc_disallow_all_hbs(xpc_vars); /* indicate we're deactivated */

for (partid = XP_MIN_PARTID; partid <= XP_MAX_PARTID; partid++) {
part = &xpc_partitions[partid];

- if (!XPC_SUPPORTS_DISENGAGE_REQUEST(part->
- remote_vars_version)) {
+ if (!XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version)) {

/* just in case it was left set by an earlier XPC */
xpc_clear_partition_engaged(partid);
@@ -1126,7 +1080,7 @@ xpc_die_disengage(void)
}

if (xpc_partition_engaged(partid) ||
- part->act_state != XPC_P_AS_INACTIVE) {
+ part->act_state != XPC_P_AS_INACTIVE) {
xpc_request_partition_disengage(part);
xpc_mark_partition_disengaged(part);
xpc_IPI_send_disengage(part);
@@ -1135,9 +1089,9 @@ xpc_die_disengage(void)

time = rtc_time();
printmsg_time = time +
- (XPC_DISENGAGE_PRINTMSG_INTERVAL * xp_rtc_cycles_per_second);
+ (XPC_DISENGAGE_PRINTMSG_INTERVAL * xp_rtc_cycles_per_second);
disengage_request_timeout = time +
- (xpc_disengage_request_timelimit * xp_rtc_cycles_per_second);
+ (xpc_disengage_request_timelimit * xp_rtc_cycles_per_second);

/* wait for all other partitions to disengage from us */

@@ -1153,8 +1107,8 @@ xpc_die_disengage(void)
partid++) {
if (xpc_partition_engaged(partid)) {
dev_info(xpc_part, "disengage from "
- "remote partition %d timed "
- "out\n", partid);
+ "remote partition %d timed "
+ "out\n", partid);
}
}
break;
@@ -1162,18 +1116,17 @@ xpc_die_disengage(void)

if (time >= printmsg_time) {
dev_info(xpc_part, "waiting for remote partitions to "
- "disengage, timeout in %ld seconds\n",
- (disengage_request_timeout - time) /
- xp_rtc_cycles_per_second);
+ "disengage, timeout in %ld seconds\n",
+ (disengage_request_timeout - time) /
+ xp_rtc_cycles_per_second);
printmsg_time = time +
- (XPC_DISENGAGE_PRINTMSG_INTERVAL *
- xp_rtc_cycles_per_second);
+ (XPC_DISENGAGE_PRINTMSG_INTERVAL *
+ xp_rtc_cycles_per_second);
}
}
}
#endif /* CONFIG_IA64 */

-
/*
* This function is called when the system is being restarted or halted due
* to some sort of system failure. If this is the case we need to notify the
@@ -1185,7 +1138,7 @@ xpc_die_disengage(void)
static int
xpc_system_die(struct notifier_block *nb, unsigned long event, void *unused)
{
-#ifdef CONFIG_IA64 /* >>> will deal with notify_die events on X86_64 shortly */
+#ifdef CONFIG_IA64 /* >>> will deal with notify_die events on X86_64 shortly */
switch (event) {
case DIE_MACHINE_RESTART:
case DIE_MACHINE_HALT:
@@ -1220,7 +1173,6 @@ xpc_system_die(struct notifier_block *nb
return NOTIFY_DONE;
}

-
int __init
xpc_init(void)
{
@@ -1257,7 +1209,7 @@ xpc_init(void)
for (partid = XP_MIN_PARTID; partid <= XP_MAX_PARTID; partid++) {
part = &xpc_partitions[partid];

- DBUG_ON((u64) part != L1_CACHE_ALIGN((u64) part));
+ DBUG_ON((u64)part != L1_CACHE_ALIGN((u64)part));

part->act_IRQ_rcvd = 0;
spin_lock_init(&part->lock);
@@ -1266,8 +1218,8 @@ xpc_init(void)

init_timer(&part->disengage_request_timer);
part->disengage_request_timer.function =
- xpc_timeout_partition_disengage_request;
- part->disengage_request_timer.data = (unsigned long) part;
+ xpc_timeout_partition_disengage_request;
+ part->disengage_request_timer.data = (unsigned long)part;

part->setup_state = XPC_P_SS_UNSET;
init_waitqueue_head(&part->teardown_wq);
@@ -1294,7 +1246,7 @@ xpc_init(void)
* but rather immediately process the interrupt.
*/
ret = request_irq(SGI_XPC_ACTIVATE, xpc_act_IRQ_handler, 0,
- "xpc hb", NULL);
+ "xpc hb", NULL);
if (ret != 0) {
dev_err(xpc_part, "can't register ACTIVATE IRQ handler, "
"errno=%d\n", -ret);
@@ -1332,7 +1284,8 @@ xpc_init(void)
buf_size = max(XPC_RP_VARS_SIZE,
XPC_RP_HEADER_SIZE + xp_sizeof_nasid_mask);
xpc_remote_copy_buffer = xpc_kmalloc_cacheline_aligned(buf_size,
- GFP_KERNEL, &xpc_remote_copy_buffer_base);
+ GFP_KERNEL,
+ &xpc_remote_copy_buffer_base);
if (xpc_remote_copy_buffer == NULL) {
dev_err(xpc_part, "could not allocate remote copy buffer\n");

@@ -1349,7 +1302,6 @@ xpc_init(void)
return -ENOMEM;
}

-
/* add ourselves to the reboot_notifier_list */
ret = register_reboot_notifier(&xpc_reboot_notifier);
if (ret != 0) {
@@ -1377,10 +1329,10 @@ xpc_init(void)
xpc_rsvd_page->vars_pa = 0;

/* take ourselves off of the reboot_notifier_list */
- (void) unregister_reboot_notifier(&xpc_reboot_notifier);
+ (void)unregister_reboot_notifier(&xpc_reboot_notifier);

/* take ourselves off of the die_notifier list */
- (void) unregister_die_notifier(&xpc_die_notifier);
+ (void)unregister_die_notifier(&xpc_die_notifier);

del_timer_sync(&xpc_hb_timer);
free_irq(SGI_XPC_ACTIVATE, NULL);
@@ -1395,7 +1347,6 @@ xpc_init(void)
return -EBUSY;
}

-
/*
* Startup a thread that will attempt to discover other partitions to
* activate based on info provided by SAL. This new thread is short
@@ -1412,7 +1363,6 @@ xpc_init(void)
return -EBUSY;
}

-
/* set the interface to point at XPC's functions */
xpc_set_interface(xpc_initiate_connect, xpc_initiate_disconnect,
xpc_initiate_allocate, xpc_initiate_send,
@@ -1421,16 +1371,16 @@ xpc_init(void)

return 0;
}
-module_init(xpc_init);

+module_init(xpc_init);

void __exit
xpc_exit(void)
{
xpc_do_exit(xpUnloading);
}
-module_exit(xpc_exit);

+module_exit(xpc_exit);

MODULE_AUTHOR("Silicon Graphics, Inc.");
MODULE_DESCRIPTION("Cross Partition Communication (XPC) support");
@@ -1438,17 +1388,16 @@ MODULE_LICENSE("GPL");

module_param(xpc_hb_interval, int, 0);
MODULE_PARM_DESC(xpc_hb_interval, "Number of seconds between "
- "heartbeat increments.");
+ "heartbeat increments.");

module_param(xpc_hb_check_interval, int, 0);
MODULE_PARM_DESC(xpc_hb_check_interval, "Number of seconds between "
- "heartbeat checks.");
+ "heartbeat checks.");

module_param(xpc_disengage_request_timelimit, int, 0);
MODULE_PARM_DESC(xpc_disengage_request_timelimit, "Number of seconds to wait "
- "for disengage request to complete.");
+ "for disengage request to complete.");

module_param(xpc_kdebug_ignore, int, 0);
MODULE_PARM_DESC(xpc_kdebug_ignore, "Should lack of heartbeat be ignored by "
- "other partitions when dropping into kdebug.");
-
+ "other partitions when dropping into kdebug.");
Index: linux-2.6/drivers/misc/xp/xpc_partition.c
===================================================================
--- linux-2.6.orig/drivers/misc/xp/xpc_partition.c 2008-03-21 13:30:52.034175000 -0500
+++ linux-2.6/drivers/misc/xp/xpc_partition.c 2008-03-24 19:31:37.154185684 -0500
@@ -6,7 +6,6 @@
* Copyright (c) 2004-2008 Silicon Graphics, Inc. All Rights Reserved.
*/

-
/*
* Cross Partition Communication (XPC) partition support.
*
@@ -16,7 +15,6 @@
*
*/

-
#include <linux/kernel.h>
#include <linux/sysctl.h>
#include <linux/cache.h>
@@ -32,11 +30,9 @@
#error architecture is NOT supported
#endif

-
/* XPC is exiting flag */
int xpc_exiting;

-
/* this partition's reserved page pointers */
struct xpc_rsvd_page *xpc_rsvd_page;
static u64 *xpc_part_nasids;
@@ -44,7 +40,6 @@ static u64 *xpc_mach_nasids;
struct xpc_vars *xpc_vars;
struct xpc_vars_part *xpc_vars_part;

-
/*
* For performance reasons, each entry of xpc_partitions[] is cacheline
* aligned. And xpc_partitions[] is padded with an additional entry at the
@@ -53,7 +48,6 @@ struct xpc_vars_part *xpc_vars_part;
*/
struct xpc_partition xpc_partitions[XP_NPARTITIONS + 1];

-
/*
* Generic buffer used to store a local copy of portions of a remote
* partition's reserved page (either its header and part_nasids mask,
@@ -62,7 +56,6 @@ struct xpc_partition xpc_partitions[XP_N
char *xpc_remote_copy_buffer;
void *xpc_remote_copy_buffer_base;

-
/*
* Guarantee that the kmalloc'd memory is cacheline aligned.
*/
@@ -74,7 +67,7 @@ xpc_kmalloc_cacheline_aligned(size_t siz
if (*base == NULL) {
return NULL;
}
- if ((u64) *base == L1_CACHE_ALIGN((u64) *base)) {
+ if ((u64)*base == L1_CACHE_ALIGN((u64)*base)) {
return *base;
}
kfree(*base);
@@ -84,10 +77,9 @@ xpc_kmalloc_cacheline_aligned(size_t siz
if (*base == NULL) {
return NULL;
}
- return (void *) L1_CACHE_ALIGN((u64) *base);
+ return (void *)L1_CACHE_ALIGN((u64)*base);
}

-
/*
* Given a nasid, get the physical address of the partition's reserved page
* for that nasid. This function returns 0 on any error.
@@ -103,7 +95,6 @@ xpc_get_rsvd_page_pa(int nasid)
size_t buf_len = 0;
void *buf_base = NULL;

-
while (1) {

ret = xp_get_partition_rsvd_page_pa(buf, &cookie, &rp_pa, &len);
@@ -120,7 +111,8 @@ xpc_get_rsvd_page_pa(int nasid)
kfree(buf_base);
buf_len = L1_CACHE_ALIGN(len);
buf = (u64)xpc_kmalloc_cacheline_aligned(buf_len,
- GFP_KERNEL, &buf_base);
+ GFP_KERNEL,
+ &buf_base);
if (buf_base == NULL) {
dev_err(xpc_part, "unable to kmalloc "
"len=0x%016lx\n", buf_len);
@@ -146,7 +138,6 @@ xpc_get_rsvd_page_pa(int nasid)
return rp_pa;
}

-
/*
* Fill the partition reserved page with the information needed by
* other partitions to discover we are alive and establish initial
@@ -166,7 +157,6 @@ xpc_rsvd_page_init(void)
int disengage_request_amos;
int ret;

-
/* get the local reserved page's address */

preempt_disable();
@@ -176,7 +166,7 @@ xpc_rsvd_page_init(void)
dev_err(xpc_part, "SAL failed to locate the reserved page\n");
return NULL;
}
- rp = (struct xpc_rsvd_page *) __va(rp_pa);
+ rp = (struct xpc_rsvd_page *)__va(rp_pa);

rp->version = XPC_RP_VERSION;

@@ -238,12 +228,11 @@ xpc_rsvd_page_init(void)
xpc_vars->act_phys_cpuid = cpu_physical_id(0);
xpc_vars->vars_part_pa = __pa(xpc_vars_part);
xpc_vars->amos_page_pa = xp_pa((u64)amos_page);
- xpc_vars->amos_page = amos_page; /* save for next load of XPC */
-
+ xpc_vars->amos_page = amos_page; /* save for next load of XPC */

/* clear xpc_vars_part */
memset((u64 *)xpc_vars_part, 0, sizeof(struct xpc_vars_part) *
- XP_NPARTITIONS);
+ XP_NPARTITIONS);

/* initialize the activate IRQ related AMO variables */
activate_irq_amos = xpc_activate_irq_amos(XP_NPARTITIONS);
@@ -271,7 +260,6 @@ xpc_rsvd_page_init(void)
return rp;
}

-
/*
* At periodic intervals, scan through all active partitions and ensure
* their heartbeat is still active. If not, the partition is deactivated.
@@ -284,8 +272,7 @@ xpc_check_remote_hb(void)
short partid;
enum xp_retval ret;

-
- remote_vars = (struct xpc_vars *) xpc_remote_copy_buffer;
+ remote_vars = (struct xpc_vars *)xpc_remote_copy_buffer;

for (partid = XP_MIN_PARTID; partid <= XP_MAX_PARTID; partid++) {

@@ -300,7 +287,7 @@ xpc_check_remote_hb(void)
part = &xpc_partitions[partid];

if (part->act_state == XPC_P_AS_INACTIVE ||
- part->act_state == XPC_P_AS_DEACTIVATING) {
+ part->act_state == XPC_P_AS_DEACTIVATING) {
continue;
}

@@ -320,8 +307,8 @@ xpc_check_remote_hb(void)
remote_vars->heartbeat_offline);

if (((remote_vars->heartbeat == part->last_heartbeat) &&
- (remote_vars->heartbeat_offline == 0)) ||
- !xpc_hb_allowed(xp_partition_id, remote_vars)) {
+ (remote_vars->heartbeat_offline == 0)) ||
+ !xpc_hb_allowed(xp_partition_id, remote_vars)) {

XPC_DEACTIVATE_PARTITION(part, xpNoHeartbeat);
continue;
@@ -331,7 +318,6 @@ xpc_check_remote_hb(void)
}
}

-
/*
* Get a copy of a portion of the remote partition's rsvd page.
*
@@ -341,12 +327,11 @@ xpc_check_remote_hb(void)
*/
static enum xp_retval
xpc_get_remote_rp(int nasid, u64 *discovered_nasids,
- struct xpc_rsvd_page *remote_rp, u64 *remote_rp_pa)
+ struct xpc_rsvd_page *remote_rp, u64 *remote_rp_pa)
{
int i;
enum xp_retval ret;

-
/* get the reserved page's physical address */

*remote_rp_pa = xpc_get_rsvd_page_pa(nasid);
@@ -354,7 +339,6 @@ xpc_get_remote_rp(int nasid, u64 *discov
return xpNoRsvdPageAddr;
}

-
/* pull over the reserved page header and part_nasids mask */
ret = xp_remote_memcpy(remote_rp, (void *)*remote_rp_pa,
XPC_RP_HEADER_SIZE + xp_sizeof_nasid_mask);
@@ -362,25 +346,22 @@ xpc_get_remote_rp(int nasid, u64 *discov
return ret;
}

-
if (discovered_nasids != NULL) {
u64 *remote_part_nasids = XPC_RP_PART_NASIDS(remote_rp);

-
for (i = 0; i < xp_nasid_mask_words(); i++) {
discovered_nasids[i] |= remote_part_nasids[i];
}
}

if (XPC_VERSION_MAJOR(remote_rp->version) !=
- XPC_VERSION_MAJOR(XPC_RP_VERSION)) {
+ XPC_VERSION_MAJOR(XPC_RP_VERSION)) {
return xpBadVersion;
}

return xpSuccess;
}

-
/*
* Get a copy of the remote partition's XPC variables from the reserved page.
*
@@ -404,7 +385,7 @@ xpc_get_remote_vars(u64 remote_vars_pa,
}

if (XPC_VERSION_MAJOR(remote_vars->version) !=
- XPC_VERSION_MAJOR(XPC_V_VERSION)) {
+ XPC_VERSION_MAJOR(XPC_V_VERSION)) {
return xpBadVersion;
}

@@ -418,14 +399,13 @@ xpc_get_remote_vars(u64 remote_vars_pa,
return xpSuccess;
}

-
/*
* Update the remote partition's info.
*/
static void
xpc_update_partition_info(struct xpc_partition *part, u8 remote_rp_version,
- struct timespec *remote_rp_stamp, u64 remote_rp_pa,
- u64 remote_vars_pa, struct xpc_vars *remote_vars)
+ struct timespec *remote_rp_stamp, u64 remote_rp_pa,
+ u64 remote_vars_pa, struct xpc_vars *remote_vars)
{
part->remote_rp_version = remote_rp_version;
dev_dbg(xpc_part, " remote_rp_version = 0x%016x\n",
@@ -472,7 +452,6 @@ xpc_update_partition_info(struct xpc_par
part->remote_vars_version);
}

-
/*
* Prior code has determined the nasid which generated an IPI. Inspect
* that nasid to determine if its partition needs to be activated or
@@ -502,15 +481,14 @@ xpc_identify_act_IRQ_req(int nasid)
struct xpc_partition *part;
enum xp_retval ret;

-
/* pull over the reserved page structure */

- remote_rp = (struct xpc_rsvd_page *) xpc_remote_copy_buffer;
+ remote_rp = (struct xpc_rsvd_page *)xpc_remote_copy_buffer;

ret = xpc_get_remote_rp(nasid, NULL, remote_rp, &remote_rp_pa);
if (ret != xpSuccess) {
dev_warn(xpc_part, "unable to get reserved page from nasid %d, "
- "which sent interrupt, reason=%d\n", nasid, ret);
+ "which sent interrupt, reason=%d\n", nasid, ret);
return;
}

@@ -522,12 +500,12 @@ xpc_identify_act_IRQ_req(int nasid)

/* pull over the cross partition variables */

- remote_vars = (struct xpc_vars *) xpc_remote_copy_buffer;
+ remote_vars = (struct xpc_vars *)xpc_remote_copy_buffer;

ret = xpc_get_remote_vars(remote_vars_pa, remote_vars);
if (ret != xpSuccess) {
dev_warn(xpc_part, "unable to get XPC variables from nasid %d, "
- "which sent interrupt, reason=%d\n", nasid, ret);
+ "which sent interrupt, reason=%d\n", nasid, ret);
return;
}

@@ -537,15 +515,15 @@ xpc_identify_act_IRQ_req(int nasid)
part->act_IRQ_rcvd++;

dev_dbg(xpc_part, "partid for nasid %d is %d; IRQs = %d; HB = "
- "%" U64_ELL "d\n", (int) nasid, (int) partid,
+ "%" U64_ELL "d\n", (int)nasid, (int)partid,
part->act_IRQ_rcvd, remote_vars->heartbeat);

if (xpc_partition_disengaged(part) &&
- part->act_state == XPC_P_AS_INACTIVE) {
+ part->act_state == XPC_P_AS_INACTIVE) {

xpc_update_partition_info(part, remote_rp_version,
- &remote_rp_stamp, remote_rp_pa,
- remote_vars_pa, remote_vars);
+ &remote_rp_stamp, remote_rp_pa,
+ remote_vars_pa, remote_vars);

if (XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version)) {
if (xpc_partition_disengage_requested(partid)) {
@@ -569,16 +547,15 @@ xpc_identify_act_IRQ_req(int nasid)

if (!XPC_SUPPORTS_RP_STAMP(part->remote_rp_version)) {
DBUG_ON(XPC_SUPPORTS_DISENGAGE_REQUEST(part->
- remote_vars_version));
+ remote_vars_version));

if (!XPC_SUPPORTS_RP_STAMP(remote_rp_version)) {
DBUG_ON(XPC_SUPPORTS_DISENGAGE_REQUEST(remote_vars->
- version));
+ version));
/* see if the other side rebooted */
if (part->remote_amos_page_pa ==
- remote_vars->amos_page_pa &&
- xpc_hb_allowed(xp_partition_id,
- remote_vars)) {
+ remote_vars->amos_page_pa &&
+ xpc_hb_allowed(xp_partition_id, remote_vars)) {
/* doesn't look that way, so ignore the IPI */
return;
}
@@ -590,8 +567,8 @@ xpc_identify_act_IRQ_req(int nasid)
*/

xpc_update_partition_info(part, remote_rp_version,
- &remote_rp_stamp, remote_rp_pa,
- remote_vars_pa, remote_vars);
+ &remote_rp_stamp, remote_rp_pa,
+ remote_vars_pa, remote_vars);
part->reactivate_nasid = nasid;
XPC_DEACTIVATE_PARTITION(part, xpReactivating);
return;
@@ -611,15 +588,15 @@ xpc_identify_act_IRQ_req(int nasid)
xpc_clear_partition_disengage_request(partid);

xpc_update_partition_info(part, remote_rp_version,
- &remote_rp_stamp, remote_rp_pa,
- remote_vars_pa, remote_vars);
+ &remote_rp_stamp, remote_rp_pa,
+ remote_vars_pa, remote_vars);
reactivate = 1;

} else {
DBUG_ON(!XPC_SUPPORTS_DISENGAGE_REQUEST(remote_vars->version));

stamp_diff = xpc_compare_stamps(&part->remote_rp_stamp,
- &remote_rp_stamp);
+ &remote_rp_stamp);
if (stamp_diff != 0) {
DBUG_ON(stamp_diff >= 0);

@@ -632,14 +609,15 @@ xpc_identify_act_IRQ_req(int nasid)
DBUG_ON(xpc_partition_disengage_requested(partid));

xpc_update_partition_info(part, remote_rp_version,
- &remote_rp_stamp, remote_rp_pa,
- remote_vars_pa, remote_vars);
+ &remote_rp_stamp,
+ remote_rp_pa, remote_vars_pa,
+ remote_vars);
reactivate = 1;
}
}

if (part->disengage_request_timeout > 0 &&
- !xpc_partition_disengaged(part)) {
+ !xpc_partition_disengaged(part)) {
/* still waiting on other side to disengage from us */
return;
}
@@ -649,12 +627,11 @@ xpc_identify_act_IRQ_req(int nasid)
XPC_DEACTIVATE_PARTITION(part, xpReactivating);

} else if (XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version) &&
- xpc_partition_disengage_requested(partid)) {
+ xpc_partition_disengage_requested(partid)) {
XPC_DEACTIVATE_PARTITION(part, xpOtherGoingDown);
}
}

-
/*
* Loop through the activation AMO variables and process any bits
* which are set. Each bit indicates a nasid sending a partition
@@ -669,13 +646,12 @@ xpc_identify_act_IRQ_sender(void)
int w_index, b_index;
u64 *amo_va;
u64 nasid_mask;
- u64 nasid; /* remote nasid */
+ u64 nasid; /* remote nasid */
int n_IRQs_detected = 0;

amo_va = (u64 *)((u64)xpc_vars->amos_page +
- xpc_activate_irq_amos(xpc_vars->npartitions) *
- xp_sizeof_amo);
-
+ xpc_activate_irq_amos(xpc_vars->npartitions) *
+ xp_sizeof_amo);

/* scan through activation AMO variables looking for non-zero entries */
for (w_index = 0; w_index < xp_nasid_mask_words(); w_index++) {
@@ -685,8 +661,8 @@ xpc_identify_act_IRQ_sender(void)
}

ret = xp_get_amo(amo_va, XP_AMO_CLEAR, &nasid_mask);
- BUG_ON(ret != xpSuccess); /* should never happen */
- amo_va = (u64 *)((u64)amo_va + xp_sizeof_amo); /* next amo */
+ BUG_ON(ret != xpSuccess); /* should never happen */
+ amo_va = (u64 *)((u64)amo_va + xp_sizeof_amo); /* next amo */
if (nasid_mask == 0) {
/* no IRQs from nasids in this variable */
continue;
@@ -695,7 +671,6 @@ xpc_identify_act_IRQ_sender(void)
dev_dbg(xpc_part, "AMO[%d] gave back 0x%" U64_ELL "x\n",
w_index, nasid_mask);

-
/*
* If any nasid(s) in mask have been added to the machine
* since our partition was reset, this will retain the
@@ -704,7 +679,6 @@ xpc_identify_act_IRQ_sender(void)
*/
xpc_mach_nasids[w_index] |= nasid_mask;

-
/* locate the nasid(s) which sent interrupts */

for (b_index = 0; b_index < BITS_PER_LONG; b_index++) {
@@ -720,7 +694,6 @@ xpc_identify_act_IRQ_sender(void)
return n_IRQs_detected;
}

-
/*
* See if the other side has responded to a partition disengage request
* from us.
@@ -731,7 +704,6 @@ xpc_partition_disengaged(struct xpc_part
short partid = XPC_PARTID(part);
int disengaged;

-
disengaged = (xpc_partition_engaged(partid) == 0);
if (part->disengage_request_timeout) {
if (!disengaged) {
@@ -746,7 +718,7 @@ xpc_partition_disengaged(struct xpc_part
*/

dev_info(xpc_part, "disengage from remote partition %d "
- "timed out\n", partid);
+ "timed out\n", partid);
xpc_disengage_request_timedout = 1;
xpc_clear_partition_engaged(partid);
disengaged = 1;
@@ -756,11 +728,11 @@ xpc_partition_disengaged(struct xpc_part
/* cancel the timer function, provided it's not us */
if (!in_interrupt()) {
del_singleshot_timer_sync(&part->
- disengage_request_timer);
+ disengage_request_timer);
}

DBUG_ON(part->act_state != XPC_P_AS_DEACTIVATING &&
- part->act_state != XPC_P_AS_INACTIVE);
+ part->act_state != XPC_P_AS_INACTIVE);
if (part->act_state != XPC_P_AS_INACTIVE) {
xpc_wakeup_channel_mgr(part);
}
@@ -772,7 +744,6 @@ xpc_partition_disengaged(struct xpc_part
return disengaged;
}

-
/*
* Mark specified partition as active.
*/
@@ -782,7 +753,6 @@ xpc_mark_partition_active(struct xpc_par
unsigned long irq_flags;
enum xp_retval ret;

-
dev_dbg(xpc_part, "setting partition %d to ACTIVE\n", XPC_PARTID(part));

spin_lock_irqsave(&part->lock, irq_flags);
@@ -798,17 +768,15 @@ xpc_mark_partition_active(struct xpc_par
return ret;
}

-
/*
* Notify XPC that the partition is down.
*/
void
xpc_deactivate_partition(const int line, struct xpc_partition *part,
- enum xp_retval reason)
+ enum xp_retval reason)
{
unsigned long irq_flags;

-
spin_lock_irqsave(&part->lock, irq_flags);

if (part->act_state == XPC_P_AS_INACTIVE) {
@@ -822,7 +790,7 @@ xpc_deactivate_partition(const int line,
}
if (part->act_state == XPC_P_AS_DEACTIVATING) {
if ((part->reason == xpUnloading && reason != xpUnloading) ||
- reason == xpReactivating) {
+ reason == xpReactivating) {
XPC_SET_REASON(part, reason, line);
}
spin_unlock_irqrestore(&part->lock, irq_flags);
@@ -840,9 +808,9 @@ xpc_deactivate_partition(const int line,

/* set a timelimit on the disengage request */
part->disengage_request_timeout = jiffies +
- (xpc_disengage_request_timelimit * HZ);
+ (xpc_disengage_request_timelimit * HZ);
part->disengage_request_timer.expires =
- part->disengage_request_timeout;
+ part->disengage_request_timeout;
add_timer(&part->disengage_request_timer);
}

@@ -852,7 +820,6 @@ xpc_deactivate_partition(const int line,
xpc_partition_going_down(part, reason);
}

-
/*
* Mark specified partition as inactive.
*/
@@ -861,7 +828,6 @@ xpc_mark_partition_inactive(struct xpc_p
{
unsigned long irq_flags;

-
dev_dbg(xpc_part, "setting partition %d to INACTIVE\n",
XPC_PARTID(part));

@@ -871,7 +837,6 @@ xpc_mark_partition_inactive(struct xpc_p
part->remote_rp_pa = 0;
}

-
/*
* Register the remote partition's AMOs so any errors within that address
* range can be handled and cleaned up should the remote partition go down.
@@ -917,7 +882,6 @@ xpc_unregister_remote_amos(struct xpc_pa
spin_unlock_irqrestore(&part->lock, irq_flags);
}

-
/*
* SAL has provided a partition and machine mask. The partition mask
* contains a bit for each even nasid in our partition. The machine
@@ -945,15 +909,13 @@ xpc_discovery(void)
u64 *discovered_nasids;
enum xp_retval ret;

-
remote_rp = xpc_kmalloc_cacheline_aligned(XPC_RP_HEADER_SIZE +
xp_sizeof_nasid_mask,
GFP_KERNEL, &remote_rp_base);
if (remote_rp == NULL) {
return;
}
- remote_vars = (struct xpc_vars *) remote_rp;
-
+ remote_vars = (struct xpc_vars *)remote_rp;

discovered_nasids = kzalloc(sizeof(u64) * xp_nasid_mask_words(),
GFP_KERNEL);
@@ -962,7 +924,7 @@ xpc_discovery(void)
return;
}

- rp = (struct xpc_rsvd_page *) xpc_rsvd_page;
+ rp = (struct xpc_rsvd_page *)xpc_rsvd_page;

/*
* The term 'region' in this context refers to the minimum number of
@@ -985,23 +947,21 @@ xpc_discovery(void)

for (region = 0; region < max_regions; region++) {

- if ((volatile int) xpc_exiting) {
+ if ((volatile int)xpc_exiting) {
break;
}

dev_dbg(xpc_part, "searching region %d\n", region);

for (nasid = (region * region_size * 2);
- nasid < ((region + 1) * region_size * 2);
- nasid += 2) {
+ nasid < ((region + 1) * region_size * 2); nasid += 2) {

- if ((volatile int) xpc_exiting) {
+ if ((volatile int)xpc_exiting) {
break;
}

dev_dbg(xpc_part, "checking nasid %d\n", nasid);

-
if (XPC_NASID_IN_ARRAY(nasid, xpc_part_nasids)) {
dev_dbg(xpc_part, "PROM indicates Nasid %d is "
"part of the local partition; skipping "
@@ -1023,11 +983,10 @@ xpc_discovery(void)
continue;
}

-
/* pull over the reserved page structure */

ret = xpc_get_remote_rp(nasid, discovered_nasids,
- remote_rp, &remote_rp_pa);
+ remote_rp, &remote_rp_pa);
if (ret != xpSuccess) {
dev_dbg(xpc_part, "unable to get reserved page "
"from nasid %d, reason=%d\n", nasid,
@@ -1068,11 +1027,11 @@ xpc_discovery(void)
ret = xpc_register_remote_amos(part);
if (ret != xpSuccess) {
dev_warn(xpc_part, "xpc_discovery() failed to "
- "register remote AMOs for partition %d,"
- "ret=%d\n", partid, ret);
+ "register remote AMOs for partition %d,"
+ "ret=%d\n", partid, ret);

XPC_SET_REASON(part, xpPhysAddrRegFailed,
- __LINE__);
+ __LINE__);
break;
}

@@ -1088,9 +1047,9 @@ xpc_discovery(void)
remote_vars->act_phys_cpuid);

if (XPC_SUPPORTS_DISENGAGE_REQUEST(remote_vars->
- version)) {
+ version)) {
part->remote_amos_page_pa =
- remote_vars->amos_page_pa;
+ remote_vars->amos_page_pa;
xpc_mark_partition_disengaged(part);
xpc_cancel_partition_disengage_request(part);
}
@@ -1102,7 +1061,6 @@ xpc_discovery(void)
kfree(remote_rp_base);
}

-
/*
* Given a partid, get the nasids owned by that partition from the
* remote partition's reserved page.
@@ -1113,7 +1071,6 @@ xpc_initiate_partid_to_nasids(short part
struct xpc_partition *part;
u64 part_nasid_pa;

-
part = &xpc_partitions[partid];
if (part->remote_rp_pa == 0) {
return xpPartitionDown;
@@ -1121,9 +1078,8 @@ xpc_initiate_partid_to_nasids(short part

memset(nasid_mask, 0, xp_sizeof_nasid_mask);

- part_nasid_pa = (u64) XPC_RP_PART_NASIDS(part->remote_rp_pa);
+ part_nasid_pa = (u64)XPC_RP_PART_NASIDS(part->remote_rp_pa);

return xp_remote_memcpy(nasid_mask, (void *)part_nasid_pa,
xp_sizeof_nasid_mask);
}
-
Index: linux-2.6/drivers/misc/xp/xpnet.c
===================================================================
--- linux-2.6.orig/drivers/misc/xp/xpnet.c 2008-03-21 13:30:52.034175000 -0500
+++ linux-2.6/drivers/misc/xp/xpnet.c 2008-03-24 19:31:37.154185684 -0500
@@ -6,7 +6,6 @@
* Copyright (C) 1999,2001-2008 Silicon Graphics, Inc. All rights reserved.
*/

-
/*
* Cross Partition Network Interface (XPNET) support
*
@@ -21,7 +20,6 @@
*
*/

-
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
@@ -37,7 +35,6 @@
#include <asm/atomic.h>
#include "xp.h"

-
/*
* The message payload transferred by XPC.
*
@@ -76,7 +73,6 @@ struct xpnet_message {
#define XPNET_MSG_ALIGNED_SIZE (L1_CACHE_ALIGN(XPNET_MSG_SIZE))
#define XPNET_MSG_NENTRIES (PAGE_SIZE / XPNET_MSG_ALIGNED_SIZE)

-
#define XPNET_MAX_KTHREADS (XPNET_MSG_NENTRIES + 1)
#define XPNET_MAX_IDLE_KTHREADS (XPNET_MSG_NENTRIES + 1)

@@ -88,9 +84,9 @@ struct xpnet_message {
#define XPNET_VERSION_MAJOR(_v) ((_v) >> 4)
#define XPNET_VERSION_MINOR(_v) ((_v) & 0xf)

-#define XPNET_VERSION _XPNET_VERSION(1,0) /* version 1.0 */
-#define XPNET_VERSION_EMBED _XPNET_VERSION(1,1) /* version 1.1 */
-#define XPNET_MAGIC 0x88786984 /* "XNET" */
+#define XPNET_VERSION _XPNET_VERSION(1,0) /* version 1.0 */
+#define XPNET_VERSION_EMBED _XPNET_VERSION(1,1) /* version 1.1 */
+#define XPNET_MAGIC 0x88786984 /* "XNET" */

#define XPNET_VALID_MSG(_m) \
((XPNET_VERSION_MAJOR(_m->version) == XPNET_VERSION_MAJOR(XPNET_VERSION)) \
@@ -98,7 +94,6 @@ struct xpnet_message {

#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
@@ -141,14 +136,12 @@ static DEFINE_SPINLOCK(xpnet_broadcast_l
/* 32KB has been determined to be the ideal */
#define XPNET_DEF_MTU (0x8000UL)

-
/*
* The partid is encapsulated in the MAC address beginning in the following
* octet.
*/
#define XPNET_PARTID_OCTET 2 /* consists of 2 octets total */

-
/* Define the XPNET debug device structures to be used with dev_dbg() et al */

struct device_driver xpnet_dbg_name = {
@@ -156,7 +149,7 @@ struct device_driver xpnet_dbg_name = {
};

struct device xpnet_dbg_subname = {
- .bus_id = {0}, /* set to "" */
+ .bus_id = {0}, /* set to "" */
.driver = &xpnet_dbg_name
};

@@ -171,14 +164,13 @@ xpnet_receive(short partid, int channel,
struct sk_buff *skb;
enum xp_retval ret;
struct xpnet_dev_private *priv =
- (struct xpnet_dev_private *) xpnet_device->priv;
-
+ (struct xpnet_dev_private *)xpnet_device->priv;

if (!XPNET_VALID_MSG(msg)) {
/*
* Packet with a different XPC version. Ignore.
*/
- xpc_received(partid, channel, (void *) msg);
+ xpc_received(partid, channel, (void *)msg);

priv->stats.rx_errors++;

@@ -187,14 +179,13 @@ xpnet_receive(short partid, int channel,
dev_dbg(xpnet, "received 0x%" U64_ELL "x, %d, %d, %d\n", msg->buf_pa,
msg->size, msg->leadin_ignore, msg->tailout_ignore);

-
/* 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);

- xpc_received(partid, channel, (void *) msg);
+ xpc_received(partid, channel, (void *)msg);

priv->stats.rx_errors++;

@@ -220,12 +211,13 @@ xpnet_receive(short partid, int channel,
* Move the data over from the other side.
*/
if ((XPNET_VERSION_MINOR(msg->version) == 1) &&
- (msg->embedded_bytes != 0)) {
+ (msg->embedded_bytes != 0)) {
dev_dbg(xpnet, "copying embedded message. memcpy(0x%p, 0x%p, "
"%lu)\n", skb->data, &msg->data,
- (size_t) msg->embedded_bytes);
+ (size_t)msg->embedded_bytes);

- skb_copy_to_linear_data(skb, &msg->data, (size_t)msg->embedded_bytes);
+ skb_copy_to_linear_data(skb, &msg->data,
+ (size_t)msg->embedded_bytes);
} else {
dev_dbg(xpnet, "transferring buffer to the skb->data area;\n\t"
"bte_copy(0x%p, 0x%p, %hu)\n", (void *)msg->buf_pa,
@@ -233,8 +225,8 @@ xpnet_receive(short partid, int channel,
msg->size);

ret = xp_remote_memcpy((void *)((u64)skb->data &
- ~(L1_CACHE_BYTES - 1)),
- (void *)msg->buf_pa, msg->size);
+ ~(L1_CACHE_BYTES - 1)),
+ (void *)msg->buf_pa, msg->size);

if (ret != xpSuccess) {
/*
@@ -245,10 +237,10 @@ xpnet_receive(short partid, int channel,
dev_err(xpnet, "xp_remote_memcpy(0x%p, 0x%p, 0x%hx) "
"returned error=0x%x\n",
(void *)__pa((u64)skb->data &
- ~(L1_CACHE_BYTES - 1)),
+ ~(L1_CACHE_BYTES - 1)),
(void *)msg->buf_pa, msg->size, ret);

- xpc_received(partid, channel, (void *) msg);
+ xpc_received(partid, channel, (void *)msg);

priv->stats.rx_errors++;

@@ -257,7 +249,7 @@ xpnet_receive(short partid, int channel,
}

dev_dbg(xpnet, "<skb->head=0x%p skb->data=0x%p skb->tail=0x%p "
- "skb->end=0x%p skb->len=%d\n", (void *) skb->head,
+ "skb->end=0x%p skb->len=%d\n", (void *)skb->head,
(void *)skb->data, skb_tail_pointer(skb), skb_end_pointer(skb),
skb->len);

@@ -270,16 +262,14 @@ xpnet_receive(short partid, int channel,
(void *)skb->head, (void *)skb->data, skb_tail_pointer(skb),
skb_end_pointer(skb), skb->len);

-
xpnet_device->last_rx = jiffies;
priv->stats.rx_packets++;
priv->stats.rx_bytes += skb->len + ETH_HLEN;

netif_rx_ni(skb);
- xpc_received(partid, channel, (void *) msg);
+ xpc_received(partid, channel, (void *)msg);
}

-
/*
* This is the handler which XPC calls during any sort of change in
* state or message reception on a connection.
@@ -291,11 +281,11 @@ xpnet_connection_activity(enum xp_retval
DBUG_ON(partid < XP_MIN_PARTID || partid > XP_MAX_PARTID);
DBUG_ON(channel != XPC_NET_CHANNEL);

- switch(reason) {
+ switch (reason) {
case xpMsgReceived: /* message received */
DBUG_ON(data == NULL);

- xpnet_receive(partid, channel, (struct xpnet_message *) data);
+ xpnet_receive(partid, channel, (struct xpnet_message *)data);
break;

case xpConnected: /* connection completed to a partition */
@@ -325,13 +315,11 @@ xpnet_connection_activity(enum xp_retval
}
}

-
static int
xpnet_dev_open(struct net_device *dev)
{
enum xp_retval ret;

-
dev_dbg(xpnet, "calling xpc_connect(%d, 0x%p, NULL, %" U64_ELL "d, %"
U64_ELL "d, %" U64_ELL "d, %" U64_ELL "d)\n", XPC_NET_CHANNEL,
xpnet_connection_activity, XPNET_MSG_SIZE, XPNET_MSG_NENTRIES,
@@ -352,7 +340,6 @@ xpnet_dev_open(struct net_device *dev)
return 0;
}

-
static int
xpnet_dev_stop(struct net_device *dev)
{
@@ -363,7 +350,6 @@ xpnet_dev_stop(struct net_device *dev)
return 0;
}

-
static int
xpnet_dev_change_mtu(struct net_device *dev, int new_mtu)
{
@@ -380,7 +366,6 @@ xpnet_dev_change_mtu(struct net_device *
return 0;
}

-
/*
* Required for the net_device structure.
*/
@@ -390,7 +375,6 @@ xpnet_dev_set_config(struct net_device *
return 0;
}

-
/*
* Return statistics to the caller.
*/
@@ -399,13 +383,11 @@ xpnet_dev_get_stats(struct net_device *d
{
struct xpnet_dev_private *priv;

-
- priv = (struct xpnet_dev_private *) dev->priv;
+ priv = (struct xpnet_dev_private *)dev->priv;

return &priv->stats;
}

-
/*
* Notification that the other end has received the message and
* DMA'd the skb information. At this point, they are done with
@@ -414,11 +396,9 @@ xpnet_dev_get_stats(struct net_device *d
*/
static void
xpnet_send_completed(enum xp_retval reason, short partid, int channel,
- void *__qm)
+ void *__qm)
{
- struct xpnet_pending_msg *queued_msg =
- (struct xpnet_pending_msg *) __qm;
-
+ struct xpnet_pending_msg *queued_msg = (struct xpnet_pending_msg *)__qm;

DBUG_ON(queued_msg == NULL);

@@ -427,14 +407,13 @@ xpnet_send_completed(enum xp_retval reas

if (atomic_dec_return(&queued_msg->use_count) == 0) {
dev_dbg(xpnet, "all acks for skb->head=-x%p\n",
- (void *) queued_msg->skb->head);
+ (void *)queued_msg->skb->head);

dev_kfree_skb_any(queued_msg->skb);
kfree(queued_msg);
}
}

-
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)
@@ -442,7 +421,6 @@ xpnet_send(struct sk_buff *skb, struct x
struct xpnet_message *msg;
enum xp_retval ret;

-
ret = xpc_allocate(dest_partid, XPC_NET_CHANNEL, XPC_NOWAIT,
(void **)&msg);
if (unlikely(ret != xpSuccess))
@@ -478,7 +456,6 @@ xpnet_send(struct sk_buff *skb, struct x
atomic_dec(&queued_msg->use_count);
}

-
/*
* 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
@@ -497,9 +474,8 @@ xpnet_dev_hard_start_xmit(struct sk_buff
struct xpnet_dev_private *priv = (struct xpnet_dev_private *)dev->priv;
u16 embedded_bytes = 0;

-
dev_dbg(xpnet, ">skb->head=0x%p skb->data=0x%p skb->tail=0x%p "
- "skb->end=0x%p skb->len=%d\n", (void *) skb->head,
+ "skb->end=0x%p skb->len=%d\n", (void *)skb->head,
(void *)skb->data, skb_tail_pointer(skb), skb_end_pointer(skb),
skb->len);

@@ -517,16 +493,15 @@ xpnet_dev_hard_start_xmit(struct sk_buff
queued_msg = kmalloc(sizeof(struct xpnet_pending_msg), GFP_ATOMIC);
if (queued_msg == NULL) {
dev_warn(xpnet, "failed to kmalloc %ld bytes; dropping "
- "packet\n", sizeof(struct xpnet_pending_msg));
+ "packet\n", sizeof(struct xpnet_pending_msg));

priv->stats.tx_errors++;

return -ENOMEM;
}

-
/* get the beginning of the first cacheline and end of last */
- start_addr = ((u64) skb->data & ~(L1_CACHE_BYTES - 1));
+ start_addr = ((u64)skb->data & ~(L1_CACHE_BYTES - 1));
end_addr = L1_CACHE_ALIGN((u64)skb_tail_pointer(skb));

/* calculate how many bytes to embed in the XPC message */
@@ -535,7 +510,6 @@ xpnet_dev_hard_start_xmit(struct sk_buff
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
@@ -550,7 +524,7 @@ xpnet_dev_hard_start_xmit(struct sk_buff
/* we are being asked to broadcast to all partitions */
for_each_bit(dest_partid,
(unsigned long *)xpnet_broadcast_partitions,
- XP_NPARTITIONS) {
+ XP_NPARTITIONS) {
xpnet_send(skb, queued_msg, start_addr, end_addr,
embedded_bytes, dest_partid);
}
@@ -577,7 +551,6 @@ xpnet_dev_hard_start_xmit(struct sk_buff
return 0;
}

-
/*
* Deal with transmit timeouts coming from the network layer.
*/
@@ -586,21 +559,18 @@ xpnet_dev_tx_timeout(struct net_device *
{
struct xpnet_dev_private *priv;

-
- priv = (struct xpnet_dev_private *) dev->priv;
+ priv = (struct xpnet_dev_private *)dev->priv;

priv->stats.tx_errors++;
return;
}

-
static int __init
xpnet_init(void)
{
short partid;
int result = -ENOMEM;

-
if (!is_shub() && !is_uv()) {
return -ENODEV;
}
@@ -633,7 +603,7 @@ xpnet_init(void)
* MAC addresses. We chose the first octet of the MAC to be unlikely
* to collide with any vendor's officially issued MAC.
*/
- xpnet_device->dev_addr[0] = 0x02; /* locally administered, no OUI */
+ xpnet_device->dev_addr[0] = 0x02; /* locally administered, no OUI */

partid = xp_partition_id;

@@ -660,23 +630,22 @@ xpnet_init(void)

return result;
}
-module_init(xpnet_init);

+module_init(xpnet_init);

static void __exit
xpnet_exit(void)
{
dev_info(xpnet, "unregistering network device %s\n",
- xpnet_device[0].name);
+ xpnet_device[0].name);

unregister_netdev(xpnet_device);

free_netdev(xpnet_device);
}
-module_exit(xpnet_exit);

+module_exit(xpnet_exit);

MODULE_AUTHOR("Silicon Graphics, Inc.");
MODULE_DESCRIPTION("Cross Partition Network adapter (XPNET)");
MODULE_LICENSE("GPL");
-

--