Prepared XPC and XPNET for future support of SGI's UV architecture. Made changes so it compiles on x86_64. Added support for up to 256 partitions. Cleaned up BTE error conversion for is64 sn2. Signed-off-by: Dean Nelson --- arch/ia64/sn/kernel/setup.c | 4 drivers/misc/Kconfig | 2 drivers/misc/xp/Makefile | 5 drivers/misc/xp/xp.h | 382 ++++++++++---------- drivers/misc/xp/xp_main.c | 181 ++++++--- drivers/misc/xp/xp_nofault.S | 2 drivers/misc/xp/xp_sn2.c | 487 ++++++++++++++++++++++++++ drivers/misc/xp/xp_uv.c | 194 ++++++++++ drivers/misc/xp/xpc.h | 594 +++++++++++++++---------------- drivers/misc/xp/xpc_channel.c | 357 +++++++++---------- drivers/misc/xp/xpc_main.c | 273 +++++++------- drivers/misc/xp/xpc_partition.c | 670 +++++++++++++++--------------------- drivers/misc/xp/xpnet.c | 280 ++++++--------- include/asm-ia64/sn/arch.h | 5 include/asm-ia64/sn/bte.h | 5 15 files changed, 2010 insertions(+), 1431 deletions(-) Index: linux-2.6/drivers/misc/xp/xp.h =================================================================== --- linux-2.6.orig/drivers/misc/xp/xp.h 2008-03-26 10:40:03.156341458 -0500 +++ linux-2.6/drivers/misc/xp/xp.h 2008-03-26 10:41:15.529157874 -0500 @@ -3,7 +3,7 @@ * License. See the file "COPYING" in the main directory of this archive * for more details. * - * Copyright (C) 2004-2005 Silicon Graphics, Inc. All rights reserved. + * Copyright (C) 2004-2008 Silicon Graphics, Inc. All rights reserved. */ @@ -12,15 +12,28 @@ */ -#ifndef _ASM_IA64_SN_XP_H -#define _ASM_IA64_SN_XP_H +#ifndef _DRIVERS_MISC_XP_XP_H +#define _DRIVERS_MISC_XP_XP_H #include #include #include -#include -#include +#ifdef CONFIG_IA64 +#include +#endif + +/* >>> Add these two #defines to some linux header file some day. */ +#define BYTES_PER_WORD sizeof(void *) +#define BITS_PER_WORD (BYTES_PER_WORD * BITS_PER_BYTE) + +#if defined(CONFIG_IA64) +#define U64_ELL "l" +#elif defined(CONFIG_X86_64) +#define U64_ELL "ll" +#else +#error architecture is NOT supported +#endif #ifdef USE_DBUG_ON @@ -30,6 +43,23 @@ #endif +#ifndef is_shub1 +#define is_shub1() 0 +#endif + +#ifndef is_shub2 +#define is_shub2() 0 +#endif + +#ifndef is_shub +#define is_shub() 0 +#endif + +#ifndef is_uv +#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 @@ -41,60 +71,15 @@ * maximum number of nodes in the entire system divided by the minimum number * of nodes that comprise an access protection grouping. */ -#define XP_MAX_PARTITIONS 64 - - -/* - * Define the number of u64s required to represent all the C-brick nasids - * as a bitmap. The cross-partition kernel modules deal only with - * C-brick nasids, thus the need for bitmaps which don't account for - * odd-numbered (non C-brick) nasids. - */ -#define XP_MAX_PHYSNODE_ID (MAX_NUMALINK_NODES / 2) -#define XP_NASID_MASK_BYTES ((XP_MAX_PHYSNODE_ID + 7) / 8) -#define XP_NASID_MASK_WORDS ((XP_MAX_PHYSNODE_ID + 63) / 64) - +#define XP_NPARTITIONS 64 /* #of partitions allowed */ +#define XP_MAX_NPARTITIONS 256 /* max #of partitions possible */ -/* - * Wrapper for bte_copy() that should it return a failure status will retry - * the bte_copy() once in the hope that the failure was due to a temporary - * aberration (i.e., the link going down temporarily). - * - * src - physical address of the source of the transfer. - * vdst - virtual address of the destination of the transfer. - * len - number of bytes to transfer from source to destination. - * mode - see bte_copy() for definition. - * notification - see bte_copy() for definition. - * - * Note: xp_bte_copy() should never be called while holding a spinlock. - */ -static inline bte_result_t -xp_bte_copy(u64 src, u64 vdst, u64 len, u64 mode, void *notification) -{ - bte_result_t ret; - u64 pdst = ia64_tpa(vdst); - - - /* - * Ensure that the physically mapped memory is contiguous. - * - * We do this by ensuring that the memory is from region 7 only. - * If the need should arise to use memory from one of the other - * regions, then modify the BUG_ON() statement to ensure that the - * memory from that region is always physically contiguous. - */ - BUG_ON(REGION_NUMBER(vdst) != RGN_KERNEL); - - ret = bte_copy(src, pdst, len, mode, notification); - if ((ret != BTE_SUCCESS) && BTE_ERROR_RETRY(ret)) { - if (!in_interrupt()) { - cond_resched(); - } - ret = bte_copy(src, pdst, len, mode, notification); - } +#if XP_NPARTITIONS > XP_MAX_NPARTITIONS +#error XP_NPARTITIONS exceeds MAXIMUM possible. +#endif - return ret; -} +#define XP_MIN_PARTID 1 /* inclusive */ +#define XP_MAX_PARTID (XP_NPARTITIONS - 1) /* inclusive */ /* @@ -115,11 +100,11 @@ xp_bte_copy(u64 src, u64 vdst, u64 len, #define XPC_MEM_CHANNEL 0 /* memory channel number */ #define XPC_NET_CHANNEL 1 /* network channel number */ -#define XPC_NCHANNELS 2 /* #of defined channels */ -#define XPC_MAX_NCHANNELS 8 /* max #of channels allowed */ +#define XPC_NCHANNELS 2 /* #of channels allowed */ +#define XPC_MAX_NCHANNELS 8 /* max #of channels possible */ #if XPC_NCHANNELS > XPC_MAX_NCHANNELS -#error XPC_NCHANNELS exceeds MAXIMUM allowed. +#error XPC_NCHANNELS exceeds MAXIMUM possible. #endif @@ -133,7 +118,7 @@ xp_bte_copy(u64 src, u64 vdst, u64 len, * +----------------------------------------+ * | payload (user-defined message) | * | | - * : + * : * | | * +----------------------------------------+ * @@ -169,106 +154,103 @@ struct xpc_msg { /* * 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 - * xpcUnknownReason, which must have the highest numerical value.) + * xpUnknownReason, which must have the highest numerical value.) */ -enum xpc_retval { - xpcSuccess = 0, - - xpcNotConnected, /* 1: channel is not connected */ - xpcConnected, /* 2: channel connected (opened) */ - xpcRETIRED1, /* 3: (formerly xpcDisconnected) */ - - xpcMsgReceived, /* 4: message received */ - xpcMsgDelivered, /* 5: message delivered and acknowledged */ - - xpcRETIRED2, /* 6: (formerly xpcTransferFailed) */ - - xpcNoWait, /* 7: operation would require wait */ - xpcRetry, /* 8: retry operation */ - xpcTimeout, /* 9: timeout in xpc_allocate_msg_wait() */ - xpcInterrupted, /* 10: interrupted wait */ - - xpcUnequalMsgSizes, /* 11: message size disparity between sides */ - xpcInvalidAddress, /* 12: invalid address */ +enum xp_retval { + xpSuccess = 0, - xpcNoMemory, /* 13: no memory available for XPC structures */ - xpcLackOfResources, /* 14: insufficient resources for operation */ - xpcUnregistered, /* 15: channel is not registered */ - xpcAlreadyRegistered, /* 16: channel is already registered */ + xpNotConnected, /* 1: channel is not connected */ + xpConnected, /* 2: channel connected (opened) */ + xpRETIRED1, /* 3: (formerly xpDisconnected) */ - xpcPartitionDown, /* 17: remote partition is down */ - xpcNotLoaded, /* 18: XPC module is not loaded */ - xpcUnloading, /* 19: this side is unloading XPC module */ + xpMsgReceived, /* 4: message received */ + xpMsgDelivered, /* 5: message delivered and acknowledged */ - xpcBadMagic, /* 20: XPC MAGIC string not found */ + xpRETIRED2, /* 6: (formerly xpTransferFailed) */ - xpcReactivating, /* 21: remote partition was reactivated */ + xpNoWait, /* 7: operation would require wait */ + xpRetry, /* 8: retry operation */ + xpTimeout, /* 9: timeout in xpc_allocate_msg_wait() */ + xpInterrupted, /* 10: interrupted wait */ - xpcUnregistering, /* 22: this side is unregistering channel */ - xpcOtherUnregistering, /* 23: other side is unregistering channel */ + xpUnequalMsgSizes, /* 11: message size disparity between sides */ + xpInvalidAddress, /* 12: invalid address */ - xpcCloneKThread, /* 24: cloning kernel thread */ - xpcCloneKThreadFailed, /* 25: cloning kernel thread failed */ + xpNoMemory, /* 13: no memory available for XPC structures */ + xpLackOfResources, /* 14: insufficient resources for operation */ + xpUnregistered, /* 15: channel is not registered */ + xpAlreadyRegistered, /* 16: channel is already registered */ - xpcNoHeartbeat, /* 26: remote partition has no heartbeat */ + xpPartitionDown, /* 17: remote partition is down */ + xpNotLoaded, /* 18: XPC module is not loaded */ + xpUnloading, /* 19: this side is unloading XPC module */ - xpcPioReadError, /* 27: PIO read error */ - xpcPhysAddrRegFailed, /* 28: registration of phys addr range failed */ + xpBadMagic, /* 20: XPC MAGIC string not found */ - xpcBteDirectoryError, /* 29: maps to BTEFAIL_DIR */ - xpcBtePoisonError, /* 30: maps to BTEFAIL_POISON */ - xpcBteWriteError, /* 31: maps to BTEFAIL_WERR */ - xpcBteAccessError, /* 32: maps to BTEFAIL_ACCESS */ - xpcBtePWriteError, /* 33: maps to BTEFAIL_PWERR */ - xpcBtePReadError, /* 34: maps to BTEFAIL_PRERR */ - xpcBteTimeOutError, /* 35: maps to BTEFAIL_TOUT */ - xpcBteXtalkError, /* 36: maps to BTEFAIL_XTERR */ - xpcBteNotAvailable, /* 37: maps to BTEFAIL_NOTAVAIL */ - xpcBteUnmappedError, /* 38: unmapped BTEFAIL_ error */ + xpReactivating, /* 21: remote partition was reactivated */ - xpcBadVersion, /* 39: bad version number */ - xpcVarsNotSet, /* 40: the XPC variables are not set up */ - xpcNoRsvdPageAddr, /* 41: unable to get rsvd page's phys addr */ - xpcInvalidPartid, /* 42: invalid partition ID */ - xpcLocalPartid, /* 43: local partition ID */ + xpUnregistering, /* 22: this side is unregistering channel */ + xpOtherUnregistering, /* 23: other side is unregistering channel */ - xpcOtherGoingDown, /* 44: other side going down, reason unknown */ - xpcSystemGoingDown, /* 45: system is going down, reason unknown */ - xpcSystemHalt, /* 46: system is being halted */ - xpcSystemReboot, /* 47: system is being rebooted */ - xpcSystemPoweroff, /* 48: system is being powered off */ + xpCloneKThread, /* 24: cloning kernel thread */ + xpCloneKThreadFailed, /* 25: cloning kernel thread failed */ - xpcDisconnecting, /* 49: channel disconnecting (closing) */ + xpNoHeartbeat, /* 26: remote partition has no heartbeat */ - xpcOpenCloseError, /* 50: channel open/close protocol error */ + xpPioReadError, /* 27: PIO read error */ + xpPhysAddrRegFailed, /* 28: registration of phys addr range failed */ - xpcDisconnected, /* 51: channel disconnected (closed) */ + xpRETIRED3, /* 29: (formerly xpBteDirectoryError) */ + xpRETIRED4, /* 30: (formerly xpBtePoisonError) */ + xpRETIRED5, /* 31: (formerly xpBteWriteError) */ + xpRETIRED6, /* 32: (formerly xpBteAccessError) */ + xpRETIRED7, /* 33: (formerly xpBtePWriteError) */ + xpRETIRED8, /* 34: (formerly xpBtePReadError) */ + xpRETIRED9, /* 35: (formerly xpBteTimeOutError) */ + xpRETIRED10, /* 36: (formerly xpBteXtalkError) */ + xpRETIRED11, /* 37: (formerly xpBteNotAvailable) */ + xpRETIRED12, /* 38: (formerly xpBteUnmappedError) */ - xpcBteSh2Start, /* 52: BTE CRB timeout */ + xpBadVersion, /* 39: bad version number */ + xpVarsNotSet, /* 40: the XPC variables are not set up */ + xpNoRsvdPageAddr, /* 41: unable to get rsvd page's phys addr */ + xpInvalidPartid, /* 42: invalid partition ID */ + xpLocalPartid, /* 43: local partition ID */ - /* 53: 0x1 BTE Error Response Short */ - xpcBteSh2RspShort = xpcBteSh2Start + BTEFAIL_SH2_RESP_SHORT, + xpOtherGoingDown, /* 44: other side going down, reason unknown */ + xpSystemGoingDown, /* 45: system is going down, reason unknown */ + xpSystemHalt, /* 46: system is being halted */ + xpSystemReboot, /* 47: system is being rebooted */ + xpSystemPoweroff, /* 48: system is being powered off */ - /* 54: 0x2 BTE Error Response Long */ - xpcBteSh2RspLong = xpcBteSh2Start + BTEFAIL_SH2_RESP_LONG, + xpDisconnecting, /* 49: channel disconnecting (closing) */ - /* 56: 0x4 BTE Error Response DSB */ - xpcBteSh2RspDSB = xpcBteSh2Start + BTEFAIL_SH2_RESP_DSP, + xpOpenCloseError, /* 50: channel open/close protocol error */ - /* 60: 0x8 BTE Error Response Access */ - xpcBteSh2RspAccess = xpcBteSh2Start + BTEFAIL_SH2_RESP_ACCESS, + xpDisconnected, /* 51: channel disconnected (closed) */ - /* 68: 0x10 BTE Error CRB timeout */ - xpcBteSh2CRBTO = xpcBteSh2Start + BTEFAIL_SH2_CRB_TO, + xpBteCopyError, /* 52: bte_copy() returned error */ + xpSalError, /* 53: sn SAL error */ + xpNeedMoreInfo, /* 54: more info is needed by SAL */ - /* 84: 0x20 BTE Error NACK limit */ - xpcBteSh2NACKLimit = xpcBteSh2Start + BTEFAIL_SH2_NACK_LIMIT, + xpUnsupported, /* 55: unsupported functionality or resource */ + xpUnknownReason /* 56: unknown reason (must be last in list) */ +}; - /* 115: BTE end */ - xpcBteSh2End = xpcBteSh2Start + BTEFAIL_SH2_ALL, - xpcUnknownReason /* 116: 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) */ + +/* the following are valid xp_get_amo() ops */ +#define XP_AMO_LOAD 1 /* get variable contents */ +#define XP_AMO_CLEAR 2 /* get variable contents and clear variable */ + +/* the following are valid xp_change_memprotect() ops */ +#define XP_MEMPROT_DISALLOW_ALL 0 +#define XP_MEMPROT_ALLOW_CPU_AMO 1 +#define XP_MEMPROT_ALLOW_CPU_MEM 2 +#define XP_MEMPROT_ALLOW_ALL 3 /* Shub 1.1 only */ /* @@ -302,83 +284,83 @@ enum xpc_retval { * * Reason Code | Cause | Optional Data * =====================+================================+===================== - * xpcConnected | connection has been established| max #of entries + * xpConnected | connection has been established| max #of entries * | to the specified partition on | allowed in message * | the specified channel | queue * ---------------------+--------------------------------+--------------------- - * xpcMsgReceived | an XPC message arrived from | address of payload + * xpMsgReceived | an XPC message arrived from | address of payload * | the specified partition on the | * | specified channel | [the user must call * | | xpc_received() when * | | finished with the * | | payload] * ---------------------+--------------------------------+--------------------- - * xpcMsgDelivered | notification that the message | NA + * xpMsgDelivered | notification that the message | NA * | was delivered to the intended | * | recipient and that they have | * | acknowledged its receipt by | * | calling xpc_received() | * =====================+================================+===================== - * xpcUnequalMsgSizes | can't connect to the specified | NULL + * xpUnequalMsgSizes | can't connect to the specified | NULL * | partition on the specified | * | channel because of mismatched | * | message sizes | * ---------------------+--------------------------------+--------------------- - * xpcNoMemory | insufficient memory avaiable | NULL + * xpNoMemory | insufficient memory avaiable | NULL * | to allocate message queue | * ---------------------+--------------------------------+--------------------- - * xpcLackOfResources | lack of resources to create | NULL + * xpLackOfResources | lack of resources to create | NULL * | the necessary kthreads to | * | support the channel | * ---------------------+--------------------------------+--------------------- - * xpcUnregistering | this side's user has | NULL or NA + * xpUnregistering | this side's user has | NULL or NA * | unregistered by calling | * | xpc_disconnect() | * ---------------------+--------------------------------+--------------------- - * xpcOtherUnregistering| the other side's user has | NULL or NA + * xpOtherUnregistering | the other side's user has | NULL or NA * | unregistered by calling | * | xpc_disconnect() | * ---------------------+--------------------------------+--------------------- - * xpcNoHeartbeat | the other side's XPC is no | NULL or NA + * xpNoHeartbeat | the other side's XPC is no | NULL or NA * | longer heartbeating | * | | * ---------------------+--------------------------------+--------------------- - * xpcUnloading | this side's XPC module is | NULL or NA + * xpUnloading | this side's XPC module is | NULL or NA * | being unloaded | * | | * ---------------------+--------------------------------+--------------------- - * xpcOtherUnloading | the other side's XPC module is | NULL or NA + * xpOtherUnloading | the other side's XPC module is | NULL or NA * | is being unloaded | * | | * ---------------------+--------------------------------+--------------------- - * xpcPioReadError | xp_nofault_PIOR() returned an | NULL or NA + * xpPioReadError | xp_nofault_PIOR() returned an | NULL or NA * | error while sending an IPI | * | | * ---------------------+--------------------------------+--------------------- - * xpcInvalidAddress | the address either received or | NULL or NA + * xpInvalidAddress | the address either received or | NULL or NA * | sent by the specified partition| * | is invalid | * ---------------------+--------------------------------+--------------------- - * xpcBteNotAvailable | attempt to pull data from the | NULL or NA - * xpcBtePoisonError | specified partition over the | - * xpcBteWriteError | specified channel via a | - * xpcBteAccessError | bte_copy() failed | - * xpcBteTimeOutError | | - * xpcBteXtalkError | | - * xpcBteDirectoryError | | - * xpcBteGenericError | | - * xpcBteUnmappedError | | + * xpBteNotAvailable | attempt to pull data from the | NULL or NA + * xpBtePoisonError | specified partition over the | + * xpBteWriteError | specified channel via a | + * xpBteAccessError | bte_copy() failed | + * xpBteTimeOutError | | + * xpBteXtalkError | | + * xpBteDirectoryError | | + * xpBteGenericError | | + * xpBteUnmappedError | | * ---------------------+--------------------------------+--------------------- - * xpcUnknownReason | the specified channel to the | NULL or NA + * xpUnknownReason | the specified channel to the | NULL or NA * | specified partition was | * | unavailable for unknown reasons| * =====================+================================+===================== */ -typedef void (*xpc_channel_func)(enum xpc_retval reason, partid_t partid, +typedef void (*xpc_channel_func)(enum xp_retval reason, short partid, int ch_number, void *data, void *key); -typedef void (*xpc_notify_func)(enum xpc_retval reason, partid_t partid, +typedef void (*xpc_notify_func)(enum xp_retval reason, short partid, int ch_number, void *key); @@ -418,12 +400,12 @@ struct xpc_registration { struct xpc_interface { void (*connect)(int); void (*disconnect)(int); - enum xpc_retval (*allocate)(partid_t, int, u32, void **); - enum xpc_retval (*send)(partid_t, int, void *); - enum xpc_retval (*send_notify)(partid_t, int, void *, + 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)(partid_t, int, void *); - enum xpc_retval (*partid_to_nasids)(partid_t, void *); + void (*received)(short, int, void *); + enum xp_retval (*partid_to_nasids)(short, void *); }; @@ -431,55 +413,91 @@ extern struct xpc_interface xpc_interfac extern void xpc_set_interface(void (*)(int), void (*)(int), - enum xpc_retval (*)(partid_t, int, u32, void **), - enum xpc_retval (*)(partid_t, int, void *), - enum xpc_retval (*)(partid_t, int, void *, xpc_notify_func, + enum xp_retval (*)(short, int, u32, void **), + enum xp_retval (*)(short, int, void *), + enum xp_retval (*)(short, int, void *, xpc_notify_func, void *), - void (*)(partid_t, int, void *), - enum xpc_retval (*)(partid_t, void *)); + void (*)(short, int, void *), + enum xp_retval (*)(short, void *)); extern void xpc_clear_interface(void); -extern enum xpc_retval xpc_connect(int, xpc_channel_func, void *, u16, +extern enum xp_retval xpc_connect(int, xpc_channel_func, void *, u16, u16, u32, u32); extern void xpc_disconnect(int); -static inline enum xpc_retval -xpc_allocate(partid_t partid, int ch_number, u32 flags, void **payload) +static inline enum xp_retval +xpc_allocate(short partid, int ch_number, u32 flags, void **payload) { return xpc_interface.allocate(partid, ch_number, flags, payload); } -static inline enum xpc_retval -xpc_send(partid_t partid, int ch_number, void *payload) +static inline enum xp_retval +xpc_send(short partid, int ch_number, void *payload) { return xpc_interface.send(partid, ch_number, payload); } -static inline enum xpc_retval -xpc_send_notify(partid_t partid, int ch_number, void *payload, +static inline enum xp_retval +xpc_send_notify(short partid, int ch_number, void *payload, xpc_notify_func func, void *key) { return xpc_interface.send_notify(partid, ch_number, payload, func, key); } static inline void -xpc_received(partid_t partid, int ch_number, void *payload) +xpc_received(short partid, int ch_number, void *payload) { return xpc_interface.received(partid, ch_number, payload); } -static inline enum xpc_retval -xpc_partid_to_nasids(partid_t partid, void *nasids) +static inline enum xp_retval +xpc_partid_to_nasids(short partid, void *nasids) { return xpc_interface.partid_to_nasids(partid, nasids); } +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 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, + 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 *, + 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 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); -#endif /* _ASM_IA64_SN_XP_H */ +static inline int +xp_partid_mask_words(int npartitions) +{ + return DIV_ROUND_UP(npartitions, BITS_PER_WORD); +} + +static inline int +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-26 10:40:03.160341945 -0500 +++ linux-2.6/drivers/misc/xp/xp_main.c 2008-03-26 10:41:24.502251175 -0500 @@ -3,7 +3,7 @@ * License. See the file "COPYING" in the main directory of this archive * for more details. * - * Copyright (c) 2004-2005 Silicon Graphics, Inc. All Rights Reserved. + * Copyright (c) 2004-2008 Silicon Graphics, Inc. All Rights Reserved. */ @@ -17,41 +17,77 @@ #include -#include #include -#include -#include -#include -#include +#include +#include "xp.h" +/* Define the XP debug device structures to be used with dev_dbg() et al */ + +struct device_driver xp_dbg_name = { + .name = "xp" +}; + +struct device xp_dbg_subname = { + .bus_id = {0}, /* set to "" */ + .driver = &xp_dbg_name +}; + +struct device *xp = &xp_dbg_subname; /* * Target of nofault PIO read. */ u64 xp_nofault_PIOR_target; +short xp_partition_id; +u8 xp_region_size; +unsigned long xp_rtc_cycles_per_second; -/* - * xpc_registrations[] keeps track of xpc_connect()'s done by the kernel-level - * users of XPC. - */ -struct xpc_registration xpc_registrations[XPC_NCHANNELS]; +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); + +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); + +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_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, + 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); /* * Initialize the XPC interface to indicate that XPC isn't loaded. */ -static enum xpc_retval xpc_notloaded(void) { return xpcNotLoaded; } +static enum xp_retval xpc_notloaded(void) { return xpNotLoaded; } struct xpc_interface xpc_interface = { (void (*)(int)) xpc_notloaded, (void (*)(int)) xpc_notloaded, - (enum xpc_retval (*)(partid_t, int, u32, void **)) xpc_notloaded, - (enum xpc_retval (*)(partid_t, int, void *)) xpc_notloaded, - (enum xpc_retval (*)(partid_t, int, void *, xpc_notify_func, void *)) + (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 (*)(partid_t, int, void *)) xpc_notloaded, - (enum xpc_retval (*)(partid_t, void *)) xpc_notloaded + (void (*)(short, int, void *)) xpc_notloaded, + (enum xp_retval (*)(short, void *)) xpc_notloaded }; @@ -61,12 +97,12 @@ struct xpc_interface xpc_interface = { void xpc_set_interface(void (*connect)(int), void (*disconnect)(int), - enum xpc_retval (*allocate)(partid_t, int, u32, void **), - enum xpc_retval (*send)(partid_t, int, void *), - enum xpc_retval (*send_notify)(partid_t, int, void *, + 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)(partid_t, int, void *), - enum xpc_retval (*partid_to_nasids)(partid_t, void *)) + void (*received)(short, int, void *), + enum xp_retval (*partid_to_nasids)(short, void *)) { xpc_interface.connect = connect; xpc_interface.disconnect = disconnect; @@ -86,20 +122,27 @@ xpc_clear_interface(void) { xpc_interface.connect = (void (*)(int)) xpc_notloaded; xpc_interface.disconnect = (void (*)(int)) xpc_notloaded; - xpc_interface.allocate = (enum xpc_retval (*)(partid_t, int, u32, + xpc_interface.allocate = (enum xp_retval (*)(short, int, u32, void **)) xpc_notloaded; - xpc_interface.send = (enum xpc_retval (*)(partid_t, int, void *)) + xpc_interface.send = (enum xp_retval (*)(short, int, void *)) xpc_notloaded; - xpc_interface.send_notify = (enum xpc_retval (*)(partid_t, int, void *, + xpc_interface.send_notify = (enum xp_retval (*)(short, int, void *, xpc_notify_func, void *)) xpc_notloaded; - xpc_interface.received = (void (*)(partid_t, int, void *)) + xpc_interface.received = (void (*)(short, int, void *)) xpc_notloaded; - xpc_interface.partid_to_nasids = (enum xpc_retval (*)(partid_t, void *)) + 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. * @@ -116,14 +159,14 @@ xpc_clear_interface(void) * this large enough to hold their largest message. * nentries - max #of XPC message entries a message queue can contain. * The actual number, which is determined when a connection - * is established and may be less then requested, will be - * passed to the user via the xpcConnected callout. + * is established and may be less then requested, will be + * passed to the user via the xpConnected callout. * assigned_limit - max number of kthreads allowed to be processing - * messages (per connection) at any given instant. + * messages (per connection) at any given instant. * idle_limit - max number of kthreads allowed to be idle at any given - * instant. + * instant. */ -enum xpc_retval +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) { @@ -138,13 +181,13 @@ xpc_connect(int ch_number, xpc_channel_f registration = &xpc_registrations[ch_number]; if (mutex_lock_interruptible(®istration->mutex) != 0) { - return xpcInterrupted; + return xpInterrupted; } /* if XPC_CHANNEL_REGISTERED(ch_number) */ if (registration->func != NULL) { mutex_unlock(®istration->mutex); - return xpcAlreadyRegistered; + return xpAlreadyRegistered; } /* register the channel for connection */ @@ -159,7 +202,7 @@ xpc_connect(int ch_number, xpc_channel_f xpc_interface.connect(ch_number); - return xpcSuccess; + return xpSuccess; } @@ -214,43 +257,26 @@ xpc_disconnect(int ch_number) return; } +extern enum xp_retval xp_init_sn2(void); +extern enum xp_retval xp_init_uv(void); int __init xp_init(void) { - int ret, ch_number; - u64 func_addr = *(u64 *) xp_nofault_PIOR; - u64 err_func_addr = *(u64 *) xp_error_PIOR; + enum xp_retval ret; + int ch_number; + if (is_shub()) + ret = xp_init_sn2(); + else if (is_uv()) + ret = xp_init_uv(); + else + ret = xpUnsupported; - if (!ia64_platform_is("sn2")) { + if (ret != xpSuccess) { return -ENODEV; } - /* - * Register a nofault code region which performs a cross-partition - * PIO read. If the PIO read times out, the MCA handler will consume - * the error and return to a kernel-provided instruction to indicate - * an error. This PIO read exists because it is guaranteed to timeout - * if the destination is down (AMO operations do not timeout on at - * least some CPUs on Shubs <= v1.2, which unfortunately we have to - * work around). - */ - if ((ret = sn_register_nofault_code(func_addr, err_func_addr, - err_func_addr, 1, 1)) != 0) { - printk(KERN_ERR "XP: can't register nofault code, error=%d\n", - ret); - } - /* - * Setup the nofault PIO read target. (There is no special reason why - * SH_IPI_ACCESS was selected.) - */ - if (is_shub2()) { - xp_nofault_PIOR_target = SH2_IPI_ACCESS0; - } else { - xp_nofault_PIOR_target = SH1_IPI_ACCESS; - } - /* initialize the connection registration mutex */ for (ch_number = 0; ch_number < XPC_NCHANNELS; ch_number++) { mutex_init(&xpc_registrations[ch_number].mutex); @@ -260,17 +286,16 @@ xp_init(void) } module_init(xp_init); +extern void xp_exit_sn2(void); +extern void xp_exit_uv(void); void __exit xp_exit(void) { - u64 func_addr = *(u64 *) xp_nofault_PIOR; - u64 err_func_addr = *(u64 *) xp_error_PIOR; - - - /* unregister the PIO read nofault code region */ - (void) sn_register_nofault_code(func_addr, err_func_addr, - err_func_addr, 1, 0); + if (is_shub()) + xp_exit_sn2(); + else if (is_uv()) + xp_exit_uv(); } module_exit(xp_exit); @@ -279,8 +304,26 @@ MODULE_AUTHOR("Silicon Graphics, Inc."); MODULE_DESCRIPTION("Cross Partition (XP) base"); MODULE_LICENSE("GPL"); -EXPORT_SYMBOL(xp_nofault_PIOR); -EXPORT_SYMBOL(xp_nofault_PIOR_target); +EXPORT_SYMBOL(xp_partition_id); +EXPORT_SYMBOL(xp_region_size); +EXPORT_SYMBOL(xp_rtc_cycles_per_second); +EXPORT_SYMBOL(xp_remote_memcpy); +EXPORT_SYMBOL(xp_register_remote_amos); +EXPORT_SYMBOL(xp_unregister_remote_amos); +EXPORT_SYMBOL(xp_sizeof_nasid_mask); +EXPORT_SYMBOL(xp_sizeof_amo); +EXPORT_SYMBOL(xp_alloc_amos); +EXPORT_SYMBOL(xp_free_amos); +EXPORT_SYMBOL(xp_set_amo); +EXPORT_SYMBOL(xp_set_amo_with_interrupt); +EXPORT_SYMBOL(xp_get_amo); +EXPORT_SYMBOL(xp_get_partition_rsvd_page_pa); +EXPORT_SYMBOL(xp_change_memprotect); +EXPORT_SYMBOL(xp_change_memprotect_shub_wars_1_1); +EXPORT_SYMBOL(xp_allow_IPI_ops); +EXPORT_SYMBOL(xp_disallow_IPI_ops); +EXPORT_SYMBOL(xp_cpu_to_nasid); +EXPORT_SYMBOL(xp_node_to_nasid); EXPORT_SYMBOL(xpc_registrations); EXPORT_SYMBOL(xpc_interface); EXPORT_SYMBOL(xpc_clear_interface); Index: linux-2.6/drivers/misc/xp/xpc.h =================================================================== --- linux-2.6.orig/drivers/misc/xp/xpc.h 2008-03-26 10:40:03.160341945 -0500 +++ linux-2.6/drivers/misc/xp/xpc.h 2008-03-26 10:41:38.940010397 -0500 @@ -3,7 +3,7 @@ * License. See the file "COPYING" in the main directory of this archive * for more details. * - * Copyright (c) 2004-2007 Silicon Graphics, Inc. All Rights Reserved. + * Copyright (c) 2004-2008 Silicon Graphics, Inc. All Rights Reserved. */ @@ -11,8 +11,8 @@ * Cross Partition Communication (XPC) structures and macros. */ -#ifndef _ASM_IA64_SN_XPC_H -#define _ASM_IA64_SN_XPC_H +#ifndef _DRIVERS_MISC_XP_XPC_H +#define _DRIVERS_MISC_XP_XPC_H #include @@ -22,12 +22,15 @@ #include #include #include -#include -#include -#include -#include -#include -#include +#if defined(CONFIG_IA64) +#include +#elif defined(CONFIG_X86_64) +#define SGI_XPC_ACTIVATE 0x30 +#define SGI_XPC_NOTIFY 0xe7 +#else +#error architecture is NOT supported +#endif +#include "xp.h" /* @@ -43,7 +46,7 @@ /* * The next macros define word or bit representations for given * C-brick nasid in either the SAL provided bit array representing - * nasids in the partition/machine or the AMO_t array used for + * nasids in the partition/machine or the array of AMO variables used for * inter-partition initiation communications. * * For SN2 machines, C-Bricks are alway even numbered NASIDs. As @@ -51,11 +54,7 @@ * passed from SAL always be packed for C-Bricks and the * cross-partition interrupts use the same packing scheme. */ -#define XPC_NASID_W_INDEX(_n) (((_n) / 64) / 2) -#define XPC_NASID_B_INDEX(_n) (((_n) / 2) & (64 - 1)) -#define XPC_NASID_IN_ARRAY(_n, _p) ((_p)[XPC_NASID_W_INDEX(_n)] & \ - (1UL << XPC_NASID_B_INDEX(_n))) -#define XPC_NASID_FROM_W_B(_w, _b) (((_w) * 64 + (_b)) * 2) +#define XPC_NASID_IN_ARRAY(_n, _p) ((_p)[BIT_WORD((_n)/2)] & BIT_MASK((_n)/2)) #define XPC_HB_DEFAULT_INTERVAL 5 /* incr HB every x secs */ #define XPC_HB_CHECK_DEFAULT_INTERVAL 20 /* check HB every x secs */ @@ -80,8 +79,8 @@ * The first cacheline of the reserved page contains the header * (struct xpc_rsvd_page). Before SAL initialization has completed, * SAL has set up the following fields of the reserved page header: - * SAL_signature, SAL_version, partid, and nasids_size. The other - * fields are set up by XPC. (xpc_rsvd_page points to the local + * SAL_signature, SAL_version, SAL_partid, and SAL_nasids_size. The + * other fields are set up by XPC. (xpc_rsvd_page points to the local * partition's reserved page.) * * part_nasids mask @@ -112,16 +111,16 @@ struct xpc_rsvd_page { u64 SAL_signature; /* SAL: unique signature */ u64 SAL_version; /* SAL: version */ - u8 partid; /* SAL: partition ID */ + u8 SAL_partid; /* SAL: partition ID */ u8 version; - u8 pad1[6]; /* align to next u64 in cacheline */ - volatile u64 vars_pa; + u8 pad[6]; + volatile u64 vars_pa; /* physical address of struct xpc_vars */ struct timespec stamp; /* time when reserved page was setup by XPC */ u64 pad2[9]; /* align to last u64 in cacheline */ - u64 nasids_size; /* SAL: size of each nasid mask in bytes */ + u64 SAL_nasids_size; /* SAL: size of each nasid mask in bytes */ }; -#define XPC_RP_VERSION _XPC_VERSION(1,1) /* version 1.1 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)) @@ -162,65 +161,109 @@ xpc_compare_stamps(struct timespec *stam */ struct xpc_vars { u8 version; - u64 heartbeat; - u64 heartbeating_to_mask; - u64 heartbeat_offline; /* if 0, heartbeat should be changing */ + short partid; + short npartitions; /* value of XPC_NPARTITIONS */ int act_nasid; int act_phys_cpuid; u64 vars_part_pa; - u64 amos_page_pa; /* paddr of page of AMOs from MSPEC driver */ - AMO_t *amos_page; /* vaddr of page of AMOs from MSPEC driver */ + u64 amos_page_pa; /* paddr of first page of AMOs variables */ + u64 *amos_page; /* vaddr of first page of AMOs variables */ + u64 heartbeat; + u64 heartbeat_offline; /* if 0, heartbeat should be changing */ + u64 heartbeating_to_mask[BITS_TO_LONGS(XP_MAX_NPARTITIONS)]; }; -#define XPC_V_VERSION _XPC_VERSION(3,1) /* version 3.1 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(partid_t partid, struct xpc_vars *vars) +xpc_hb_allowed(short partid, struct xpc_vars *vars) { - return ((vars->heartbeating_to_mask & (1UL << partid)) != 0); + return test_bit(partid, vars->heartbeating_to_mask); +} + +static inline int +xpc_any_hbs_allowed(struct xpc_vars *vars) +{ + return !bitmap_empty((unsigned long *)vars->heartbeating_to_mask, + vars->npartitions); } static inline void -xpc_allow_hb(partid_t partid, struct xpc_vars *vars) +xpc_allow_hb(short partid, struct xpc_vars *vars) { - u64 old_mask, new_mask; + set_bit(partid, vars->heartbeating_to_mask); +} - do { - old_mask = vars->heartbeating_to_mask; - new_mask = (old_mask | (1UL << partid)); - } while (cmpxchg(&vars->heartbeating_to_mask, old_mask, new_mask) != - old_mask); +static inline void +xpc_disallow_hb(short partid, struct xpc_vars *vars) +{ + clear_bit(partid, vars->heartbeating_to_mask); } static inline void -xpc_disallow_hb(partid_t partid, struct xpc_vars *vars) +xpc_disallow_all_hbs(struct xpc_vars *vars) { - u64 old_mask, new_mask; + int nlongs = BITS_TO_LONGS(vars->npartitions); + int i; - do { - old_mask = vars->heartbeating_to_mask; - new_mask = (old_mask & ~(1UL << partid)); - } while (cmpxchg(&vars->heartbeating_to_mask, old_mask, new_mask) != - old_mask); + for (i = 0; i < nlongs; i++) + vars->heartbeating_to_mask[i] = 0; } /* - * The AMOs page consists of a number of AMO variables which are divided into - * four groups, The first two groups are used to identify an IRQ's sender. - * These two groups consist of 64 and 128 AMO variables respectively. The last - * two groups, consisting of just one AMO variable each, are used to identify - * the remote partitions that are currently engaged (from the viewpoint of - * the XPC running on the remote partition). + * 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 + * reflects state changes of up to eight channels and are accompanied by the + * receipt of a NOTIFY IRQ. The second group represents a bitmap of nasids by + * which to identify an ACTIVATE IRQ's sender. The last two groups, each + * representing a bitmap of partids, are used to identify the remote partitions + * that are currently engaged (from the viewpoint of the XPC running on the + * remote partition). + * + * The following #defines reflect an AMO index into these AMOS page(s). */ -#define XPC_NOTIFY_IRQ_AMOS 0 -#define XPC_ACTIVATE_IRQ_AMOS (XPC_NOTIFY_IRQ_AMOS + XP_MAX_PARTITIONS) -#define XPC_ENGAGED_PARTITIONS_AMO (XPC_ACTIVATE_IRQ_AMOS + XP_NASID_MASK_WORDS) -#define XPC_DISENGAGE_REQUEST_AMO (XPC_ENGAGED_PARTITIONS_AMO + 1) + +/* get offset to beginning of notify IRQ AMOs */ +static inline int +xpc_notify_irq_amos(void) +{ + return 0; +} + +/* get offset to beginning of activate IRQ AMOs */ +static inline int +xpc_activate_irq_amos(int npartitions) +{ + return xpc_notify_irq_amos() + npartitions; +} + +/* get offset to beginning of engaged partitions AMOs */ +static inline int +xpc_engaged_partitions_amos(int npartitions) +{ + return xpc_activate_irq_amos(npartitions) + xp_nasid_mask_words(); +} + +/* get offset to beginning of disengaged request AMOs */ +static inline int +xpc_disengage_request_amos(int npartitions) +{ + return xpc_engaged_partitions_amos(npartitions) + + xp_partid_mask_words(npartitions); +} + +/* get total number of AMOs */ +static inline int +xpc_number_of_amos(int npartitions) +{ + return xpc_disengage_request_amos(npartitions) + + xp_partid_mask_words(npartitions); +} /* @@ -239,7 +282,7 @@ struct xpc_vars_part { u64 openclose_args_pa; /* physical address of open and close args */ u64 GPs_pa; /* physical address of Get/Put values */ - u64 IPI_amo_pa; /* physical address of IPI AMO_t structure */ + u64 IPI_amo_pa; /* physical address of IPI AMO variable */ int IPI_nasid; /* nasid of where to send IPIs */ int IPI_phys_cpuid; /* physical CPU ID of where to send IPIs */ @@ -264,12 +307,14 @@ struct xpc_vars_part { /* the reserved page sizes and offsets */ #define XPC_RP_HEADER_SIZE L1_CACHE_ALIGN(sizeof(struct xpc_rsvd_page)) -#define XPC_RP_VARS_SIZE L1_CACHE_ALIGN(sizeof(struct xpc_vars)) +#define XPC_RP_VARS_SIZE L1_CACHE_ALIGN(sizeof(struct xpc_vars)) -#define XPC_RP_PART_NASIDS(_rp) (u64 *) ((u8 *) _rp + XPC_RP_HEADER_SIZE) -#define XPC_RP_MACH_NASIDS(_rp) (XPC_RP_PART_NASIDS(_rp) + xp_nasid_mask_words) -#define XPC_RP_VARS(_rp) ((struct xpc_vars *) XPC_RP_MACH_NASIDS(_rp) + xp_nasid_mask_words) -#define XPC_RP_VARS_PART(_rp) (struct xpc_vars_part *) ((u8 *) XPC_RP_VARS(rp) + XPC_RP_VARS_SIZE) +#define XPC_RP_PART_NASIDS(_rp) (u64 *)((u8 *)(_rp) + XPC_RP_HEADER_SIZE) +#define XPC_RP_MACH_NASIDS(_rp) (XPC_RP_PART_NASIDS(_rp) + \ + xp_nasid_mask_words()) +#define XPC_RP_VARS(_rp) (struct xpc_vars *)(XPC_RP_MACH_NASIDS(_rp) + \ + xp_nasid_mask_words()) +#define XPC_RP_VARS_PART(_rp) (struct xpc_vars_part *)((u8 *)XPC_RP_VARS(_rp) + XPC_RP_VARS_SIZE) /* @@ -428,11 +473,11 @@ struct xpc_notify { * messages. */ struct xpc_channel { - partid_t partid; /* ID of remote partition connected */ + short partid; /* ID of remote partition connected */ spinlock_t lock; /* lock for updating this structure */ u32 flags; /* general flags */ - enum xpc_retval reason; /* reason why channel is disconnect'g */ + enum xp_retval reason; /* reason why channel is disconnect'g */ int reason_line; /* line# disconnect initiated from */ u16 number; /* channel # */ @@ -481,16 +526,11 @@ struct xpc_channel { /* kthread management related fields */ -// >>> rethink having kthreads_assigned_limit and kthreads_idle_limit; perhaps -// >>> allow the assigned limit be unbounded and let the idle limit be dynamic -// >>> dependent on activity over the last interval of time atomic_t kthreads_assigned; /* #of kthreads assigned to channel */ - u32 kthreads_assigned_limit; /* limit on #of kthreads assigned */ + 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 */ - // >>> following field is temporary - u32 kthreads_created; /* total #of kthreads created */ wait_queue_head_t idle_wq; /* idle kthread wait queue */ @@ -538,6 +578,8 @@ struct xpc_partition { /* XPC HB infrastructure */ 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 */ @@ -547,10 +589,11 @@ struct xpc_partition { 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 act_lock; /* protect updating of act_state */ + 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 xpc_retval reason; /* reason partition is deactivating */ + enum xp_retval reason; /* reason partition is deactivating */ int reason_line; /* line# deactivation initiated from */ int reactivate_nasid; /* nasid in partition to reactivate */ @@ -601,9 +644,9 @@ struct xpc_partition { int remote_IPI_nasid; /* nasid of where to send IPIs */ int remote_IPI_phys_cpuid; /* phys CPU ID of where to send IPIs */ - AMO_t *remote_IPI_amo_va; /* address of remote IPI AMO_t structure */ + u64 *remote_IPI_amo_va; /* address of remote IPI AMO variable */ - AMO_t *local_IPI_amo_va; /* address of IPI AMO_t structure */ + 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 */ @@ -618,14 +661,17 @@ struct xpc_partition { } ____cacheline_aligned; +/* struct xpc_partition flags */ + +#define XPC_P_RAMOSREGISTERED 0x00000001 /* remote AMOs were registered */ /* struct xpc_partition act_state values (for XPC HB) */ -#define XPC_P_INACTIVE 0x00 /* partition is not active */ -#define XPC_P_ACTIVATION_REQ 0x01 /* created thread to activate */ -#define XPC_P_ACTIVATING 0x02 /* activation thread started */ -#define XPC_P_ACTIVE 0x03 /* xpc_partition_up() was called */ -#define XPC_P_DEACTIVATING 0x04 /* partition deactivation initiated */ +#define XPC_P_AS_INACTIVE 0x00 /* partition is not active */ +#define XPC_P_AS_ACTIVATION_REQ 0x01 /* created thread to activate */ +#define XPC_P_AS_ACTIVATING 0x02 /* activation thread started */ +#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) \ @@ -634,10 +680,10 @@ struct xpc_partition { /* struct xpc_partition setup_state values */ -#define XPC_P_UNSET 0x00 /* infrastructure was never setup */ -#define XPC_P_SETUP 0x01 /* infrastructure is setup */ -#define XPC_P_WTEARDOWN 0x02 /* waiting to teardown infrastructure */ -#define XPC_P_TORNDOWN 0x03 /* infrastructure is torndown */ +#define XPC_P_SS_UNSET 0x00 /* infrastructure was never setup */ +#define XPC_P_SS_SETUP 0x01 /* infrastructure is setup */ +#define XPC_P_SS_WTEARDOWN 0x02 /* waiting to teardown infrastructure */ +#define XPC_P_SS_TORNDOWN 0x03 /* infrastructure is torndown */ @@ -646,7 +692,7 @@ struct xpc_partition { * dropped IPIs. These occur whenever an IPI amo write doesn't complete until * after the IPI was received. */ -#define XPC_P_DROPPED_IPI_WAIT (0.25 * HZ) +#define XPC_DROPPED_IPI_WAIT_INTERVAL (0.25 * HZ) /* number of seconds to wait for other partitions to disengage */ @@ -656,7 +702,7 @@ struct xpc_partition { #define XPC_DISENGAGE_PRINTMSG_INTERVAL 10 -#define XPC_PARTID(_p) ((partid_t) ((_p) - &xpc_partitions[0])) +#define XPC_PARTID(_p) ((short) ((_p) - &xpc_partitions[0])) @@ -682,41 +728,41 @@ extern int xpc_exiting; extern struct xpc_vars *xpc_vars; extern struct xpc_rsvd_page *xpc_rsvd_page; extern struct xpc_vars_part *xpc_vars_part; -extern struct xpc_partition xpc_partitions[XP_MAX_PARTITIONS + 1]; +extern struct xpc_partition xpc_partitions[XP_NPARTITIONS + 1]; extern char *xpc_remote_copy_buffer; extern void *xpc_remote_copy_buffer_base; extern void *xpc_kmalloc_cacheline_aligned(size_t, gfp_t, void **); extern struct xpc_rsvd_page *xpc_rsvd_page_init(void); -extern void xpc_allow_IPI_ops(void); -extern void xpc_restrict_IPI_ops(void); extern int xpc_identify_act_IRQ_sender(void); extern int xpc_partition_disengaged(struct xpc_partition *); -extern enum xpc_retval xpc_mark_partition_active(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); 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 *); extern void xpc_discovery(void); extern void xpc_check_remote_hb(void); -extern void xpc_deactivate_partition(const int, struct xpc_partition *, - enum xpc_retval); -extern enum xpc_retval xpc_initiate_partid_to_nasids(partid_t, 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 xpc_retval xpc_initiate_allocate(partid_t, int, u32, void **); -extern enum xpc_retval xpc_initiate_send(partid_t, int, void *); -extern enum xpc_retval xpc_initiate_send_notify(partid_t, int, void *, +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 *); -extern void xpc_initiate_received(partid_t, int, void *); -extern enum xpc_retval xpc_setup_infrastructure(struct xpc_partition *); -extern enum xpc_retval xpc_pull_remote_vars_part(struct xpc_partition *); +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 *); extern void xpc_process_channel_activity(struct xpc_partition *); 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 xpc_retval, unsigned long *); -extern void xpc_disconnect_callout(struct xpc_channel *, enum xpc_retval); -extern void xpc_partition_going_down(struct xpc_partition *, enum xpc_retval); + 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 *); @@ -769,7 +815,7 @@ xpc_part_deref(struct xpc_partition *par DBUG_ON(refs < 0); - if (refs == 0 && part->setup_state == XPC_P_WTEARDOWN) { + if (refs == 0 && part->setup_state == XPC_P_SS_WTEARDOWN) { wake_up(&part->teardown_wq); } } @@ -781,7 +827,7 @@ xpc_part_ref(struct xpc_partition *part) atomic_inc(&part->references); - setup = (part->setup_state == XPC_P_SETUP); + setup = (part->setup_state == XPC_P_SS_SETUP); if (!setup) { xpc_part_deref(part); } @@ -811,145 +857,123 @@ xpc_part_ref(struct xpc_partition *part) static inline void xpc_mark_partition_engaged(struct xpc_partition *part) { - unsigned long irq_flags; - AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa + - (XPC_ENGAGED_PARTITIONS_AMO * sizeof(AMO_t))); - - - local_irq_save(irq_flags); + u64 *amo_va = __va(part->remote_amos_page_pa + + (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 */ - FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_OR, - (1UL << sn_partition_id)); - /* - * We must always use the nofault function regardless of whether we - * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we - * didn't, we'd never know that the other partition is down and would - * keep sending IPIs and AMOs to it until the heartbeat times out. - */ - (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo-> - variable), xp_nofault_PIOR_target)); - - local_irq_restore(irq_flags); + (void)xp_set_amo(amo_va, XP_AMO_OR, BIT_MASK(xp_partition_id), 1); } static inline void xpc_mark_partition_disengaged(struct xpc_partition *part) { - unsigned long irq_flags; - AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa + - (XPC_ENGAGED_PARTITIONS_AMO * sizeof(AMO_t))); - - - local_irq_save(irq_flags); + u64 *amo_va = __va(part->remote_amos_page_pa + + (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 */ - FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND, - ~(1UL << sn_partition_id)); - /* - * We must always use the nofault function regardless of whether we - * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we - * didn't, we'd never know that the other partition is down and would - * keep sending IPIs and AMOs to it until the heartbeat times out. - */ - (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo-> - variable), xp_nofault_PIOR_target)); - - local_irq_restore(irq_flags); + (void)xp_set_amo(amo_va, XP_AMO_AND, ~BIT_MASK(xp_partition_id), 1); } static inline void xpc_request_partition_disengage(struct xpc_partition *part) { - unsigned long irq_flags; - AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa + - (XPC_DISENGAGE_REQUEST_AMO * sizeof(AMO_t))); - - - local_irq_save(irq_flags); + u64 *amo_va = __va(part->remote_amos_page_pa + + (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 */ - FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_OR, - (1UL << sn_partition_id)); - /* - * We must always use the nofault function regardless of whether we - * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we - * didn't, we'd never know that the other partition is down and would - * keep sending IPIs and AMOs to it until the heartbeat times out. - */ - (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo-> - variable), xp_nofault_PIOR_target)); - - local_irq_restore(irq_flags); + (void)xp_set_amo(amo_va, XP_AMO_OR, BIT_MASK(xp_partition_id), 1); } static inline void xpc_cancel_partition_disengage_request(struct xpc_partition *part) { - unsigned long irq_flags; - AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa + - (XPC_DISENGAGE_REQUEST_AMO * sizeof(AMO_t))); - - - local_irq_save(irq_flags); + u64 *amo_va = __va(part->remote_amos_page_pa + + (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 */ - FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND, - ~(1UL << sn_partition_id)); - /* - * We must always use the nofault function regardless of whether we - * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we - * didn't, we'd never know that the other partition is down and would - * keep sending IPIs and AMOs to it until the heartbeat times out. - */ - (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo-> - variable), xp_nofault_PIOR_target)); - - local_irq_restore(irq_flags); + (void)xp_set_amo(amo_va, XP_AMO_AND, ~BIT_MASK(xp_partition_id), 1); } -static inline u64 -xpc_partition_engaged(u64 partid_mask) +static inline int +xpc_any_partition_engaged(void) { - AMO_t *amo = xpc_vars->amos_page + XPC_ENGAGED_PARTITIONS_AMO; + 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); + 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 */ + if (amo != 0) + return 1; - - /* return our partition's AMO variable ANDed with partid_mask */ - return (FETCHOP_LOAD_OP(TO_AMO((u64) &amo->variable), FETCHOP_LOAD) & - partid_mask); + amo_va = (u64 *)((u64)amo_va + xp_sizeof_amo); + } + return 0; } static inline u64 -xpc_partition_disengage_requested(u64 partid_mask) +xpc_partition_engaged(short partid) { - AMO_t *amo = xpc_vars->amos_page + XPC_DISENGAGE_REQUEST_AMO; + 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); + 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 */ + return (amo & BIT_MASK(partid)); +} +static inline u64 +xpc_partition_disengage_requested(short partid) +{ + 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); + u64 amo; - /* return our partition's AMO variable ANDed with partid_mask */ - return (FETCHOP_LOAD_OP(TO_AMO((u64) &amo->variable), FETCHOP_LOAD) & - partid_mask); + /* 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 */ + return (amo & BIT_MASK(partid)); } static inline void -xpc_clear_partition_engaged(u64 partid_mask) +xpc_clear_partition_engaged(short partid) { - AMO_t *amo = xpc_vars->amos_page + XPC_ENGAGED_PARTITIONS_AMO; + 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); - - /* clear bit(s) based on partid_mask in our partition's AMO */ - FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND, - ~partid_mask); + /* 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 */ } static inline void -xpc_clear_partition_disengage_request(u64 partid_mask) +xpc_clear_partition_disengage_request(short partid) { - AMO_t *amo = xpc_vars->amos_page + XPC_DISENGAGE_REQUEST_AMO; - + 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); - /* clear bit(s) based on partid_mask in our partition's AMO */ - FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND, - ~partid_mask); + /* 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 */ } @@ -961,40 +985,6 @@ xpc_clear_partition_disengage_request(u6 * the other that is associated with channel activity (SGI_XPC_NOTIFY). */ -static inline u64 -xpc_IPI_receive(AMO_t *amo) -{ - return FETCHOP_LOAD_OP(TO_AMO((u64) &amo->variable), FETCHOP_CLEAR); -} - - -static inline enum xpc_retval -xpc_IPI_send(AMO_t *amo, u64 flag, int nasid, int phys_cpuid, int vector) -{ - int ret = 0; - unsigned long irq_flags; - - - local_irq_save(irq_flags); - - FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_OR, flag); - sn_send_IPI_phys(nasid, phys_cpuid, vector, 0); - - /* - * We must always use the nofault function regardless of whether we - * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we - * didn't, we'd never know that the other partition is down and would - * keep sending IPIs and AMOs to it until the heartbeat times out. - */ - ret = xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo->variable), - xp_nofault_PIOR_target)); - - local_irq_restore(irq_flags); - - return ((ret == 0) ? xpcSuccess : xpcPioReadError); -} - - /* * IPIs associated with SGI_XPC_ACTIVATE IRQ. */ @@ -1004,44 +994,53 @@ xpc_IPI_send(AMO_t *amo, u64 flag, int n */ static inline void xpc_activate_IRQ_send(u64 amos_page_pa, int from_nasid, int to_nasid, - int to_phys_cpuid) + int to_phys_cpuid, int remote_amo, int npartitions) { - int w_index = XPC_NASID_W_INDEX(from_nasid); - int b_index = XPC_NASID_B_INDEX(from_nasid); - AMO_t *amos = (AMO_t *) __va(amos_page_pa + - (XPC_ACTIVATE_IRQ_AMOS * sizeof(AMO_t))); - - - (void) xpc_IPI_send(&amos[w_index], (1UL << b_index), to_nasid, - to_phys_cpuid, SGI_XPC_ACTIVATE); + enum xp_retval ret; + /* 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); + + ret = xp_set_amo_with_interrupt(amo_va, XP_AMO_OR, + BIT_MASK(from_nasid/2), + remote_amo, to_nasid, + to_phys_cpuid, SGI_XPC_ACTIVATE); + BUG_ON(!remote_amo && ret != xpSuccess); /* should never happen*/ } static inline void xpc_IPI_send_activate(struct xpc_vars *vars) { - xpc_activate_IRQ_send(vars->amos_page_pa, cnodeid_to_nasid(0), - vars->act_nasid, vars->act_phys_cpuid); + xpc_activate_IRQ_send(vars->amos_page_pa, xp_node_to_nasid(0), + vars->act_nasid, vars->act_phys_cpuid, 1, + vars->npartitions); } static inline void xpc_IPI_send_activated(struct xpc_partition *part) { - xpc_activate_IRQ_send(part->remote_amos_page_pa, cnodeid_to_nasid(0), - part->remote_act_nasid, part->remote_act_phys_cpuid); + xpc_activate_IRQ_send(part->remote_amos_page_pa, xp_node_to_nasid(0), + part->remote_act_nasid, + part->remote_act_phys_cpuid, 1, + part->remote_npartitions); } static inline void xpc_IPI_send_reactivate(struct xpc_partition *part) { xpc_activate_IRQ_send(xpc_vars->amos_page_pa, part->reactivate_nasid, - xpc_vars->act_nasid, xpc_vars->act_phys_cpuid); + xpc_vars->act_nasid, xpc_vars->act_phys_cpuid, 0, + xpc_vars->npartitions); } static inline void xpc_IPI_send_disengage(struct xpc_partition *part) { - xpc_activate_IRQ_send(part->remote_amos_page_pa, cnodeid_to_nasid(0), - part->remote_act_nasid, part->remote_act_phys_cpuid); + xpc_activate_IRQ_send(part->remote_amos_page_pa, xp_node_to_nasid(0), + part->remote_act_nasid, + part->remote_act_phys_cpuid, 1, + part->remote_npartitions); } @@ -1061,26 +1060,25 @@ xpc_notify_IRQ_send(struct xpc_channel * unsigned long *irq_flags) { struct xpc_partition *part = &xpc_partitions[ch->partid]; - enum xpc_retval ret; + enum xp_retval ret; + + if (unlikely(part->act_state == XPC_P_AS_DEACTIVATING)) + return; - if (likely(part->act_state != XPC_P_DEACTIVATING)) { - ret = xpc_IPI_send(part->remote_IPI_amo_va, - (u64) ipi_flag << (ch->number * 8), + ret = xp_set_amo_with_interrupt(part->remote_IPI_amo_va, XP_AMO_OR, + ((u64)ipi_flag << (ch->number * 8)), 1, part->remote_IPI_nasid, part->remote_IPI_phys_cpuid, SGI_XPC_NOTIFY); - dev_dbg(xpc_chan, "%s sent to partid=%d, channel=%d, ret=%d\n", - ipi_flag_string, ch->partid, ch->number, ret); - if (unlikely(ret != xpcSuccess)) { - if (irq_flags != NULL) { - spin_unlock_irqrestore(&ch->lock, *irq_flags); - } - XPC_DEACTIVATE_PARTITION(part, ret); - if (irq_flags != NULL) { - spin_lock_irqsave(&ch->lock, *irq_flags); - } - } + dev_dbg(xpc_chan, "%s sent to partid=%d, channel=%d, ret=%d\n", + ipi_flag_string, ch->partid, ch->number, ret); + if (unlikely(ret != xpSuccess)) { + if (irq_flags != NULL) + spin_unlock_irqrestore(&ch->lock, *irq_flags); + XPC_DEACTIVATE_PARTITION(part, ret); + if (irq_flags != NULL) + spin_lock_irqsave(&ch->lock, *irq_flags); } } @@ -1097,11 +1095,14 @@ static inline void xpc_notify_IRQ_send_local(struct xpc_channel *ch, u8 ipi_flag, char *ipi_flag_string) { - struct xpc_partition *part = &xpc_partitions[ch->partid]; + 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 */ - FETCHOP_STORE_OP(TO_AMO((u64) &part->local_IPI_amo_va->variable), - FETCHOP_OR, ((u64) ipi_flag << (ch->number * 8))); dev_dbg(xpc_chan, "%s sent local from partid=%d, channel=%d\n", ipi_flag_string, ch->partid, ch->number); } @@ -1126,8 +1127,8 @@ xpc_notify_IRQ_send_local(struct xpc_cha #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)) -#define XPC_ANY_OPENCLOSE_IPI_FLAGS_SET(_amo) ((_amo) & __IA64_UL_CONST(0x0f0f0f0f0f0f0f0f)) -#define XPC_ANY_MSG_IPI_FLAGS_SET(_amo) ((_amo) & __IA64_UL_CONST(0x1010101010101010)) +#define XPC_ANY_OPENCLOSE_IPI_FLAGS_SET(_amo) ((_amo) & 0x0f0f0f0f0f0f0f0fUL) +#define XPC_ANY_MSG_IPI_FLAGS_SET(_amo) ((_amo) & 0x1010101010101010UL) static inline void @@ -1185,53 +1186,16 @@ xpc_IPI_send_local_msgrequest(struct xpc } -/* - * Memory for XPC's AMO variables is allocated by the MSPEC driver. These - * pages are located in the lowest granule. The lowest granule uses 4k pages - * for cached references and an alternate TLB handler to never provide a - * cacheable mapping for the entire region. This will prevent speculative - * reading of cached copies of our lines from being issued which will cause - * a PI FSB Protocol error to be generated by the SHUB. For XPC, we need 64 - * AMO variables (based on XP_MAX_PARTITIONS) for message notification and an - * additional 128 AMO variables (based on XP_NASID_MASK_WORDS) for partition - * activation and 2 AMO variables for partition deactivation. - */ -static inline AMO_t * +static inline u64 * xpc_IPI_init(int index) { - AMO_t *amo = xpc_vars->amos_page + index; - - - (void) xpc_IPI_receive(amo); /* clear AMO variable */ - return amo; -} - - - -static inline enum xpc_retval -xpc_map_bte_errors(bte_result_t error) -{ - if (error == BTE_SUCCESS) - return xpcSuccess; - - if (is_shub2()) { - if (BTE_VALID_SH2_ERROR(error)) - return xpcBteSh2Start + error; - return xpcBteUnmappedError; - } - switch (error) { - case BTE_SUCCESS: return xpcSuccess; - case BTEFAIL_DIR: return xpcBteDirectoryError; - case BTEFAIL_POISON: return xpcBtePoisonError; - case BTEFAIL_WERR: return xpcBteWriteError; - case BTEFAIL_ACCESS: return xpcBteAccessError; - case BTEFAIL_PWERR: return xpcBtePWriteError; - case BTEFAIL_PRERR: return xpcBtePReadError; - case BTEFAIL_TOUT: return xpcBteTimeOutError; - case BTEFAIL_XTERR: return xpcBteXtalkError; - case BTEFAIL_NOTAVAIL: return xpcBteNotAvailable; - default: return xpcBteUnmappedError; - } + enum xp_retval ret; + 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 */ + return amo_va; } @@ -1243,11 +1207,13 @@ xpc_map_bte_errors(bte_result_t error) static inline void xpc_check_for_channel_activity(struct xpc_partition *part) { + enum xp_retval ret; u64 IPI_amo; unsigned long irq_flags; - IPI_amo = xpc_IPI_receive(part->local_IPI_amo_va); + ret = xp_get_amo(part->local_IPI_amo_va, XP_AMO_CLEAR, &IPI_amo); + BUG_ON(ret != xpSuccess); /* should never happen */ if (IPI_amo == 0) { return; } @@ -1256,12 +1222,12 @@ xpc_check_for_channel_activity(struct xp part->local_IPI_amo |= IPI_amo; spin_unlock_irqrestore(&part->IPI_lock, irq_flags); - dev_dbg(xpc_chan, "received IPI from partid=%d, IPI_amo=0x%lx\n", - XPC_PARTID(part), IPI_amo); + dev_dbg(xpc_chan, "received IPI from partid=%d, IPI_amo=0x%" U64_ELL + "x\n", XPC_PARTID(part), IPI_amo); xpc_wakeup_channel_mgr(part); } -#endif /* _ASM_IA64_SN_XPC_H */ +#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-26 10:40:03.160341945 -0500 +++ linux-2.6/drivers/misc/xp/xpc_channel.c 2008-03-26 10:41:46.712957569 -0500 @@ -3,7 +3,7 @@ * License. See the file "COPYING" in the main directory of this archive * for more details. * - * Copyright (c) 2004-2006 Silicon Graphics, Inc. All Rights Reserved. + * Copyright (c) 2004-2008 Silicon Graphics, Inc. All Rights Reserved. */ @@ -23,9 +23,11 @@ #include #include #include -#include -#include -#include +#include "xpc.h" + +#ifdef CONFIG_X86_64 +#define cmpxchg_rel(ptr,o,n) cmpxchg(ptr,o,n) +#endif /* @@ -57,7 +59,7 @@ xpc_kzalloc_cacheline_aligned(size_t siz * Set up the initial values for the XPartition Communication channels. */ static void -xpc_initialize_channels(struct xpc_partition *part, partid_t partid) +xpc_initialize_channels(struct xpc_partition *part, short partid) { int ch_number; struct xpc_channel *ch; @@ -96,12 +98,12 @@ xpc_initialize_channels(struct xpc_parti * Setup the infrastructure necessary to support XPartition Communication * between the specified remote partition and the local one. */ -enum xpc_retval +enum xp_retval xpc_setup_infrastructure(struct xpc_partition *part) { int ret, cpuid; struct timer_list *timer; - partid_t partid = XPC_PARTID(part); + short partid = XPC_PARTID(part); /* @@ -121,7 +123,7 @@ xpc_setup_infrastructure(struct xpc_part GFP_KERNEL); if (part->channels == NULL) { dev_err(xpc_chan, "can't get memory for channels\n"); - return xpcNoMemory; + return xpNoMemory; } part->nchannels = XPC_NCHANNELS; @@ -136,7 +138,7 @@ xpc_setup_infrastructure(struct xpc_part part->channels = NULL; dev_err(xpc_chan, "can't get memory for local get/put " "values\n"); - return xpcNoMemory; + return xpNoMemory; } part->remote_GPs = xpc_kzalloc_cacheline_aligned(XPC_GP_SIZE, @@ -148,7 +150,7 @@ xpc_setup_infrastructure(struct xpc_part part->local_GPs = NULL; kfree(part->channels); part->channels = NULL; - return xpcNoMemory; + return xpNoMemory; } @@ -165,7 +167,7 @@ xpc_setup_infrastructure(struct xpc_part part->local_GPs = NULL; kfree(part->channels); part->channels = NULL; - return xpcNoMemory; + return xpNoMemory; } part->remote_openclose_args = xpc_kzalloc_cacheline_aligned( @@ -181,7 +183,7 @@ xpc_setup_infrastructure(struct xpc_part part->local_GPs = NULL; kfree(part->channels); part->channels = NULL; - return xpcNoMemory; + return xpNoMemory; } @@ -193,8 +195,8 @@ xpc_setup_infrastructure(struct xpc_part /* local_IPI_amo were set to 0 by an earlier memset() */ - /* Initialize this partitions AMO_t structure */ - part->local_IPI_amo_va = xpc_IPI_init(partid); + /* Initialize this partitions AMO structure */ + part->local_IPI_amo_va = xpc_IPI_init(xpc_notify_irq_amos() + partid); spin_lock_init(&part->IPI_lock); @@ -217,7 +219,7 @@ xpc_setup_infrastructure(struct xpc_part part->local_GPs = NULL; kfree(part->channels); part->channels = NULL; - return xpcLackOfResources; + return xpLackOfResources; } /* Setup a timer to check for dropped IPIs */ @@ -225,14 +227,14 @@ xpc_setup_infrastructure(struct xpc_part init_timer(timer); timer->function = (void (*)(unsigned long)) xpc_dropped_IPI_check; timer->data = (unsigned long) part; - timer->expires = jiffies + XPC_P_DROPPED_IPI_WAIT; + timer->expires = jiffies + XPC_DROPPED_IPI_WAIT_INTERVAL; add_timer(timer); /* - * With the setting of the partition setup_state to XPC_P_SETUP, we're - * declaring that this partition is ready to go. + * With the setting of the partition setup_state to XPC_P_SS_SETUP, + * we're declaring that this partition is ready to go. */ - part->setup_state = XPC_P_SETUP; + part->setup_state = XPC_P_SS_SETUP; /* @@ -247,12 +249,12 @@ xpc_setup_infrastructure(struct xpc_part __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 = cpuid_to_nasid(cpuid); + xpc_vars_part[partid].IPI_nasid = xp_cpu_to_nasid(cpuid); xpc_vars_part[partid].IPI_phys_cpuid = cpu_physical_id(cpuid); xpc_vars_part[partid].nchannels = part->nchannels; xpc_vars_part[partid].magic = XPC_VP_MAGIC1; - return xpcSuccess; + return xpSuccess; } @@ -260,35 +262,32 @@ xpc_setup_infrastructure(struct xpc_part * Create a wrapper that hides the underlying mechanism for pulling a cacheline * (or multiple cachelines) from a remote partition. * - * src must be a cacheline aligned physical address on the remote partition. - * dst must be a cacheline aligned virtual address on this partition. - * cnt must be an cacheline sized + * src must be a cacheline-aligned physical address on the remote partition. + * dst must be a cacheline-aligned virtual address on this partition. + * cnt must be cacheline sized */ -static enum xpc_retval +static enum xp_retval xpc_pull_remote_cachelines(struct xpc_partition *part, void *dst, const void *src, size_t cnt) { - bte_result_t bte_ret; + enum xp_retval ret; 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_DEACTIVATING) { + if (part->act_state == XPC_P_AS_DEACTIVATING) { return part->reason; } - bte_ret = xp_bte_copy((u64) src, (u64) dst, (u64) cnt, - (BTE_NORMAL | BTE_WACQUIRE), NULL); - if (bte_ret == BTE_SUCCESS) { - return xpcSuccess; + ret = xp_remote_memcpy(dst, src, cnt); + if (ret != xpSuccess) { + dev_dbg(xpc_chan, "xp_remote_memcpy() from partition %d failed," + " ret=%d\n", XPC_PARTID(part), ret); } - dev_dbg(xpc_chan, "xp_bte_copy() from partition %d failed, ret=%d\n", - XPC_PARTID(part), bte_ret); - - return xpc_map_bte_errors(bte_ret); + return ret; } @@ -296,7 +295,7 @@ xpc_pull_remote_cachelines(struct xpc_pa * Pull the remote per partition specific variables from the specified * partition. */ -enum xpc_retval +enum xp_retval xpc_pull_remote_vars_part(struct xpc_partition *part) { u8 buffer[L1_CACHE_BYTES * 2]; @@ -304,8 +303,8 @@ xpc_pull_remote_vars_part(struct xpc_par (struct xpc_vars_part *) L1_CACHE_ALIGN((u64) buffer); struct xpc_vars_part *pulled_entry; u64 remote_entry_cacheline_pa, remote_entry_pa; - partid_t partid = XPC_PARTID(part); - enum xpc_retval ret; + short partid = XPC_PARTID(part); + enum xp_retval ret; /* pull the cacheline that contains the variables we're interested in */ @@ -315,7 +314,7 @@ xpc_pull_remote_vars_part(struct xpc_par DBUG_ON(sizeof(struct xpc_vars_part) != L1_CACHE_BYTES / 2); remote_entry_pa = part->remote_vars_part_pa + - sn_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)); @@ -325,7 +324,7 @@ xpc_pull_remote_vars_part(struct xpc_par ret = xpc_pull_remote_cachelines(part, pulled_entry_cacheline, (void *) remote_entry_cacheline_pa, L1_CACHE_BYTES); - if (ret != xpcSuccess) { + if (ret != xpSuccess) { dev_dbg(xpc_chan, "failed to pull XPC vars_part from " "partition %d, ret=%d\n", partid, ret); return ret; @@ -339,13 +338,14 @@ xpc_pull_remote_vars_part(struct xpc_par if (pulled_entry->magic != 0) { dev_dbg(xpc_chan, "partition %d's XPC vars_part for " - "partition %d has bad magic value (=0x%lx)\n", - partid, sn_partition_id, pulled_entry->magic); - return xpcBadMagic; + "partition %d has bad magic value (=0x%" + U64_ELL "x)\n", partid, xp_partition_id, + pulled_entry->magic); + return xpBadMagic; } /* they've not been initialized yet */ - return xpcRetry; + return xpRetry; } if (xpc_vars_part[partid].magic == XPC_VP_MAGIC1) { @@ -358,8 +358,8 @@ xpc_pull_remote_vars_part(struct xpc_par dev_err(xpc_chan, "partition %d's XPC vars_part for " "partition %d are not valid\n", partid, - sn_partition_id); - return xpcInvalidAddress; + xp_partition_id); + return xpInvalidAddress; } /* the variables we imported look to be valid */ @@ -367,8 +367,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; - part->remote_IPI_amo_va = - (AMO_t *) __va(pulled_entry->IPI_amo_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; @@ -382,10 +381,10 @@ xpc_pull_remote_vars_part(struct xpc_par } if (pulled_entry->magic == XPC_VP_MAGIC1) { - return xpcRetry; + return xpRetry; } - return xpcSuccess; + return xpSuccess; } @@ -397,7 +396,7 @@ xpc_get_IPI_flags(struct xpc_partition * { unsigned long irq_flags; u64 IPI_amo; - enum xpc_retval ret; + enum xp_retval ret; /* @@ -416,7 +415,7 @@ xpc_get_IPI_flags(struct xpc_partition * part->remote_openclose_args, (void *) part->remote_openclose_args_pa, XPC_OPENCLOSE_ARGS_SIZE); - if (ret != xpcSuccess) { + if (ret != xpSuccess) { XPC_DEACTIVATE_PARTITION(part, ret); dev_dbg(xpc_chan, "failed to pull openclose args from " @@ -432,7 +431,7 @@ xpc_get_IPI_flags(struct xpc_partition * ret = xpc_pull_remote_cachelines(part, part->remote_GPs, (void *) part->remote_GPs_pa, XPC_GP_SIZE); - if (ret != xpcSuccess) { + if (ret != xpSuccess) { XPC_DEACTIVATE_PARTITION(part, ret); dev_dbg(xpc_chan, "failed to pull GPs from partition " @@ -450,18 +449,13 @@ xpc_get_IPI_flags(struct xpc_partition * /* * Allocate the local message queue and the notify queue. */ -static enum xpc_retval +static enum xp_retval xpc_allocate_local_msgqueue(struct xpc_channel *ch) { unsigned long irq_flags; int nentries; size_t nbytes; - - // >>> may want to check for ch->flags & XPC_C_DISCONNECTING between - // >>> iterations of the for-loop, bail if set? - - // >>> should we impose a minimum #of entries? like 4 or 8? for (nentries = ch->local_nentries; nentries > 0; nentries--) { nbytes = nentries * ch->msg_size; @@ -489,19 +483,19 @@ xpc_allocate_local_msgqueue(struct xpc_c ch->local_nentries = nentries; } spin_unlock_irqrestore(&ch->lock, irq_flags); - return xpcSuccess; + return xpSuccess; } dev_dbg(xpc_chan, "can't get memory for local message queue and notify " "queue, partid=%d, channel=%d\n", ch->partid, ch->number); - return xpcNoMemory; + return xpNoMemory; } /* * Allocate the cached remote message queue. */ -static enum xpc_retval +static enum xp_retval xpc_allocate_remote_msgqueue(struct xpc_channel *ch) { unsigned long irq_flags; @@ -511,10 +505,6 @@ xpc_allocate_remote_msgqueue(struct xpc_ DBUG_ON(ch->remote_nentries <= 0); - // >>> may want to check for ch->flags & XPC_C_DISCONNECTING between - // >>> iterations of the for-loop, bail if set? - - // >>> should we impose a minimum #of entries? like 4 or 8? for (nentries = ch->remote_nentries; nentries > 0; nentries--) { nbytes = nentries * ch->msg_size; @@ -534,12 +524,12 @@ xpc_allocate_remote_msgqueue(struct xpc_ ch->remote_nentries = nentries; } spin_unlock_irqrestore(&ch->lock, irq_flags); - return xpcSuccess; + return xpSuccess; } dev_dbg(xpc_chan, "can't get memory for cached remote message queue, " "partid=%d, channel=%d\n", ch->partid, ch->number); - return xpcNoMemory; + return xpNoMemory; } @@ -548,20 +538,20 @@ xpc_allocate_remote_msgqueue(struct xpc_ * * Note: Assumes all of the channel sizes are filled in. */ -static enum xpc_retval +static enum xp_retval xpc_allocate_msgqueues(struct xpc_channel *ch) { unsigned long irq_flags; - enum xpc_retval ret; + enum xp_retval ret; DBUG_ON(ch->flags & XPC_C_SETUP); - if ((ret = xpc_allocate_local_msgqueue(ch)) != xpcSuccess) { + if ((ret = xpc_allocate_local_msgqueue(ch)) != xpSuccess) { return ret; } - if ((ret = xpc_allocate_remote_msgqueue(ch)) != xpcSuccess) { + if ((ret = xpc_allocate_remote_msgqueue(ch)) != xpSuccess) { kfree(ch->local_msgqueue_base); ch->local_msgqueue = NULL; kfree(ch->notify_queue); @@ -573,7 +563,7 @@ xpc_allocate_msgqueues(struct xpc_channe ch->flags |= XPC_C_SETUP; spin_unlock_irqrestore(&ch->lock, irq_flags); - return xpcSuccess; + return xpSuccess; } @@ -586,7 +576,7 @@ xpc_allocate_msgqueues(struct xpc_channe static void xpc_process_connect(struct xpc_channel *ch, unsigned long *irq_flags) { - enum xpc_retval ret; + enum xp_retval ret; DBUG_ON(!spin_is_locked(&ch->lock)); @@ -603,7 +593,7 @@ xpc_process_connect(struct xpc_channel * ret = xpc_allocate_msgqueues(ch); spin_lock_irqsave(&ch->lock, *irq_flags); - if (ret != xpcSuccess) { + if (ret != xpSuccess) { XPC_DISCONNECT_CHANNEL(ch, ret, irq_flags); } if (ch->flags & (XPC_C_CONNECTED | XPC_C_DISCONNECTING)) { @@ -641,7 +631,7 @@ xpc_process_connect(struct xpc_channel * * Notify those who wanted to be notified upon delivery of their message. */ static void -xpc_notify_senders(struct xpc_channel *ch, enum xpc_retval reason, s64 put) +xpc_notify_senders(struct xpc_channel *ch, enum xp_retval reason, s64 put) { struct xpc_notify *notify; u8 notify_type; @@ -671,16 +661,17 @@ xpc_notify_senders(struct xpc_channel *c if (notify->func != NULL) { dev_dbg(xpc_chan, "notify->func() called, notify=0x%p, " - "msg_number=%ld, partid=%d, channel=%d\n", - (void *) notify, get, ch->partid, ch->number); + "msg_number=%" U64_ELL "d, partid=%d, " + "channel=%d\n", (void *) notify, get, + ch->partid, ch->number); notify->func(reason, ch->partid, ch->number, notify->key); dev_dbg(xpc_chan, "notify->func() returned, " - "notify=0x%p, msg_number=%ld, partid=%d, " - "channel=%d\n", (void *) notify, get, - ch->partid, ch->number); + "notify=0x%p, msg_number=%" U64_ELL "d, " + "partid=%d, channel=%d\n", (void *) notify, + get, ch->partid, ch->number); } } } @@ -761,9 +752,9 @@ xpc_process_disconnect(struct xpc_channe DBUG_ON((ch->flags & XPC_C_CONNECTEDCALLOUT_MADE) && !(ch->flags & XPC_C_DISCONNECTINGCALLOUT_MADE)); - if (part->act_state == XPC_P_DEACTIVATING) { + if (part->act_state == XPC_P_AS_DEACTIVATING) { /* can't proceed until the other side disengages from us */ - if (xpc_partition_engaged(1UL << ch->partid)) { + if (xpc_partition_engaged(ch->partid)) { return; } @@ -795,7 +786,7 @@ xpc_process_disconnect(struct xpc_channe if (ch->flags & XPC_C_DISCONNECTINGCALLOUT_MADE) { spin_unlock_irqrestore(&ch->lock, *irq_flags); - xpc_disconnect_callout(ch, xpcDisconnected); + xpc_disconnect_callout(ch, xpDisconnected); spin_lock_irqsave(&ch->lock, *irq_flags); } @@ -816,7 +807,7 @@ xpc_process_disconnect(struct xpc_channe /* we won't lose the CPU since we're holding ch->lock */ complete(&ch->wdisconnect_wait); } else if (ch->delayed_IPI_flags) { - if (part->act_state != XPC_P_DEACTIVATING) { + if (part->act_state != XPC_P_AS_DEACTIVATING) { /* time to take action on any delayed IPI flags */ spin_lock(&part->IPI_lock); XPC_SET_IPI_FLAGS(part->local_IPI_amo, ch->number, @@ -839,7 +830,7 @@ xpc_process_openclose_IPI(struct xpc_par struct xpc_openclose_args *args = &part->remote_openclose_args[ch_number]; struct xpc_channel *ch = &part->channels[ch_number]; - enum xpc_retval reason; + enum xp_retval reason; @@ -921,10 +912,10 @@ again: if (!(ch->flags & XPC_C_DISCONNECTING)) { reason = args->reason; - if (reason <= xpcSuccess || reason > xpcUnknownReason) { - reason = xpcUnknownReason; - } else if (reason == xpcUnregistering) { - reason = xpcOtherUnregistering; + if (reason <= xpSuccess || reason > xpUnknownReason) { + reason = xpUnknownReason; + } else if (reason == xpUnregistering) { + reason = xpOtherUnregistering; } XPC_DISCONNECT_CHANNEL(ch, reason, &irq_flags); @@ -944,7 +935,7 @@ again: " channel=%d\n", ch->partid, ch->number); if (ch->flags & XPC_C_DISCONNECTED) { - DBUG_ON(part->act_state != XPC_P_DEACTIVATING); + DBUG_ON(part->act_state != XPC_P_AS_DEACTIVATING); spin_unlock_irqrestore(&ch->lock, irq_flags); return; } @@ -981,7 +972,7 @@ again: "channel=%d\n", args->msg_size, args->local_nentries, ch->partid, ch->number); - if (part->act_state == XPC_P_DEACTIVATING || + if (part->act_state == XPC_P_AS_DEACTIVATING || (ch->flags & XPC_C_ROPENREQUEST)) { spin_unlock_irqrestore(&ch->lock, irq_flags); return; @@ -1014,7 +1005,7 @@ again: if (ch->flags & XPC_C_OPENREQUEST) { if (args->msg_size != ch->msg_size) { - XPC_DISCONNECT_CHANNEL(ch, xpcUnequalMsgSizes, + XPC_DISCONNECT_CHANNEL(ch, xpUnequalMsgSizes, &irq_flags); spin_unlock_irqrestore(&ch->lock, irq_flags); return; @@ -1034,18 +1025,18 @@ again: if (IPI_flags & XPC_IPI_OPENREPLY) { - dev_dbg(xpc_chan, "XPC_IPI_OPENREPLY (local_msgqueue_pa=0x%lx, " - "local_nentries=%d, remote_nentries=%d) received from " - "partid=%d, channel=%d\n", args->local_msgqueue_pa, - args->local_nentries, args->remote_nentries, - ch->partid, ch->number); + dev_dbg(xpc_chan, "XPC_IPI_OPENREPLY (local_msgqueue_pa=0x%" + U64_ELL "x, local_nentries=%d, remote_nentries=%d) " + "received from partid=%d, channel=%d\n", + args->local_msgqueue_pa, args->local_nentries, + args->remote_nentries, ch->partid, ch->number); if (ch->flags & (XPC_C_DISCONNECTING | XPC_C_DISCONNECTED)) { spin_unlock_irqrestore(&ch->lock, irq_flags); return; } if (!(ch->flags & XPC_C_OPENREQUEST)) { - XPC_DISCONNECT_CHANNEL(ch, xpcOpenCloseError, + XPC_DISCONNECT_CHANNEL(ch, xpOpenCloseError, &irq_flags); spin_unlock_irqrestore(&ch->lock, irq_flags); return; @@ -1097,7 +1088,7 @@ again: /* * Attempt to establish a channel connection to a remote partition. */ -static enum xpc_retval +static enum xp_retval xpc_connect_channel(struct xpc_channel *ch) { unsigned long irq_flags; @@ -1105,12 +1096,12 @@ xpc_connect_channel(struct xpc_channel * if (mutex_trylock(®istration->mutex) == 0) { - return xpcRetry; + return xpRetry; } if (!XPC_CHANNEL_REGISTERED(ch->number)) { mutex_unlock(®istration->mutex); - return xpcUnregistered; + return xpUnregistered; } spin_lock_irqsave(&ch->lock, irq_flags); @@ -1153,10 +1144,10 @@ xpc_connect_channel(struct xpc_channel * * the channel lock as needed. */ mutex_unlock(®istration->mutex); - XPC_DISCONNECT_CHANNEL(ch, xpcUnequalMsgSizes, + XPC_DISCONNECT_CHANNEL(ch, xpUnequalMsgSizes, &irq_flags); spin_unlock_irqrestore(&ch->lock, irq_flags); - return xpcUnequalMsgSizes; + return xpUnequalMsgSizes; } } else { ch->msg_size = registration->msg_size; @@ -1179,7 +1170,7 @@ xpc_connect_channel(struct xpc_channel * spin_unlock_irqrestore(&ch->lock, irq_flags); - return xpcSuccess; + return xpSuccess; } @@ -1268,7 +1259,7 @@ xpc_process_msg_IPI(struct xpc_partition * Notify senders that messages sent have been * received and delivered by the other side. */ - xpc_notify_senders(ch, xpcMsgDelivered, + xpc_notify_senders(ch, xpMsgDelivered, ch->remote_GP.get); } @@ -1280,9 +1271,9 @@ xpc_process_msg_IPI(struct xpc_partition ch->w_remote_GP.get = ch->remote_GP.get; - dev_dbg(xpc_chan, "w_remote_GP.get changed to %ld, partid=%d, " - "channel=%d\n", ch->w_remote_GP.get, ch->partid, - ch->number); + dev_dbg(xpc_chan, "w_remote_GP.get changed to %" U64_ELL "d, " + "partid=%d, channel=%d\n", ch->w_remote_GP.get, + ch->partid, ch->number); /* * If anyone was waiting for message queue entries to become @@ -1308,9 +1299,9 @@ xpc_process_msg_IPI(struct xpc_partition ch->w_remote_GP.put = ch->remote_GP.put; - dev_dbg(xpc_chan, "w_remote_GP.put changed to %ld, partid=%d, " - "channel=%d\n", ch->w_remote_GP.put, ch->partid, - ch->number); + dev_dbg(xpc_chan, "w_remote_GP.put changed to %" U64_ELL "d, " + "partid=%d, channel=%d\n", ch->w_remote_GP.put, + ch->partid, ch->number); nmsgs_sent = ch->w_remote_GP.put - ch->w_local_GP.get; if (nmsgs_sent > 0) { @@ -1371,7 +1362,7 @@ xpc_process_channel_activity(struct xpc_ continue; } - if (part->act_state == XPC_P_DEACTIVATING) { + if (part->act_state == XPC_P_AS_DEACTIVATING) { continue; } @@ -1411,7 +1402,7 @@ xpc_process_channel_activity(struct xpc_ * at the same time. */ void -xpc_partition_going_down(struct xpc_partition *part, enum xpc_retval reason) +xpc_partition_going_down(struct xpc_partition *part, enum xp_retval reason) { unsigned long irq_flags; int ch_number; @@ -1454,7 +1445,7 @@ xpc_partition_going_down(struct xpc_part void xpc_teardown_infrastructure(struct xpc_partition *part) { - partid_t partid = XPC_PARTID(part); + short partid = XPC_PARTID(part); /* @@ -1468,8 +1459,8 @@ xpc_teardown_infrastructure(struct xpc_p DBUG_ON(atomic_read(&part->nchannels_engaged) != 0); DBUG_ON(atomic_read(&part->nchannels_active) != 0); - DBUG_ON(part->setup_state != XPC_P_SETUP); - part->setup_state = XPC_P_WTEARDOWN; + DBUG_ON(part->setup_state != XPC_P_SS_SETUP); + part->setup_state = XPC_P_SS_WTEARDOWN; xpc_vars_part[partid].magic = 0; @@ -1486,7 +1477,7 @@ xpc_teardown_infrastructure(struct xpc_p /* now we can begin tearing down the infrastructure */ - part->setup_state = XPC_P_TORNDOWN; + part->setup_state = XPC_P_SS_TORNDOWN; /* in case we've still got outstanding timers registered... */ del_timer_sync(&part->dropped_IPI_timer); @@ -1512,14 +1503,14 @@ xpc_teardown_infrastructure(struct xpc_p void xpc_initiate_connect(int ch_number) { - partid_t partid; + short partid; struct xpc_partition *part; struct xpc_channel *ch; DBUG_ON(ch_number < 0 || ch_number >= XPC_NCHANNELS); - for (partid = 1; partid < XP_MAX_PARTITIONS; partid++) { + for (partid = XP_MIN_PARTID; partid <= XP_MAX_PARTID; partid++) { part = &xpc_partitions[partid]; if (xpc_part_ref(part)) { @@ -1542,13 +1533,13 @@ xpc_connected_callout(struct xpc_channel /* let the registerer know that a connection has been established */ if (ch->func != NULL) { - dev_dbg(xpc_chan, "ch->func() called, reason=xpcConnected, " + dev_dbg(xpc_chan, "ch->func() called, reason=xpConnected, " "partid=%d, channel=%d\n", ch->partid, ch->number); - ch->func(xpcConnected, ch->partid, ch->number, + ch->func(xpConnected, ch->partid, ch->number, (void *) (u64) ch->local_nentries, ch->key); - dev_dbg(xpc_chan, "ch->func() returned, reason=xpcConnected, " + dev_dbg(xpc_chan, "ch->func() returned, reason=xpConnected, " "partid=%d, channel=%d\n", ch->partid, ch->number); } } @@ -1571,7 +1562,7 @@ void xpc_initiate_disconnect(int ch_number) { unsigned long irq_flags; - partid_t partid; + short partid; struct xpc_partition *part; struct xpc_channel *ch; @@ -1579,7 +1570,7 @@ xpc_initiate_disconnect(int ch_number) DBUG_ON(ch_number < 0 || ch_number >= XPC_NCHANNELS); /* initiate the channel disconnect for every active partition */ - for (partid = 1; partid < XP_MAX_PARTITIONS; partid++) { + for (partid = XP_MIN_PARTID; partid <= XP_MAX_PARTID; partid++) { part = &xpc_partitions[partid]; if (xpc_part_ref(part)) { @@ -1591,7 +1582,7 @@ xpc_initiate_disconnect(int ch_number) if (!(ch->flags & XPC_C_DISCONNECTED)) { ch->flags |= XPC_C_WDISCONNECT; - XPC_DISCONNECT_CHANNEL(ch, xpcUnregistering, + XPC_DISCONNECT_CHANNEL(ch, xpUnregistering, &irq_flags); } @@ -1617,7 +1608,7 @@ xpc_initiate_disconnect(int ch_number) */ void xpc_disconnect_channel(const int line, struct xpc_channel *ch, - enum xpc_retval reason, unsigned long *irq_flags) + enum xp_retval reason, unsigned long *irq_flags) { u32 channel_was_connected = (ch->flags & XPC_C_CONNECTED); @@ -1654,7 +1645,7 @@ xpc_disconnect_channel(const int line, s } else if ((ch->flags & XPC_C_CONNECTEDCALLOUT_MADE) && !(ch->flags & XPC_C_DISCONNECTINGCALLOUT)) { - /* start a kthread that will do the xpcDisconnecting callout */ + /* start a kthread that will do the xpDisconnecting callout */ xpc_create_kthreads(ch, 1, 1); } @@ -1668,7 +1659,7 @@ xpc_disconnect_channel(const int line, s void -xpc_disconnect_callout(struct xpc_channel *ch, enum xpc_retval reason) +xpc_disconnect_callout(struct xpc_channel *ch, enum xp_retval reason) { /* * Let the channel's registerer know that the channel is being @@ -1692,14 +1683,14 @@ 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. */ -static enum xpc_retval +static enum xp_retval xpc_allocate_msg_wait(struct xpc_channel *ch) { - enum xpc_retval ret; + enum xp_retval ret; if (ch->flags & XPC_C_DISCONNECTING) { - DBUG_ON(ch->reason == xpcInterrupted); // >>> Is this true? + DBUG_ON(ch->reason == xpInterrupted); return ch->reason; } @@ -1709,11 +1700,11 @@ xpc_allocate_msg_wait(struct xpc_channel if (ch->flags & XPC_C_DISCONNECTING) { ret = ch->reason; - DBUG_ON(ch->reason == xpcInterrupted); // >>> Is this true? + DBUG_ON(ch->reason == xpInterrupted); } else if (ret == 0) { - ret = xpcTimeout; + ret = xpTimeout; } else { - ret = xpcInterrupted; + ret = xpInterrupted; } return ret; @@ -1724,12 +1715,12 @@ xpc_allocate_msg_wait(struct xpc_channel * Allocate an entry for a message from the message queue associated with the * specified channel. */ -static enum xpc_retval +static enum xp_retval xpc_allocate_msg(struct xpc_channel *ch, u32 flags, struct xpc_msg **address_of_msg) { struct xpc_msg *msg; - enum xpc_retval ret; + enum xp_retval ret; s64 put; @@ -1742,7 +1733,7 @@ xpc_allocate_msg(struct xpc_channel *ch, } if (!(ch->flags & XPC_C_CONNECTED)) { xpc_msgqueue_deref(ch); - return xpcNotConnected; + return xpNotConnected; } @@ -1751,7 +1742,7 @@ xpc_allocate_msg(struct xpc_channel *ch, * If none are available, we'll make sure that we grab the latest * GP values. */ - ret = xpcTimeout; + ret = xpTimeout; while (1) { @@ -1764,7 +1755,7 @@ xpc_allocate_msg(struct xpc_channel *ch, * 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) { /* we got the entry referenced by put */ @@ -1783,17 +1774,17 @@ xpc_allocate_msg(struct xpc_channel *ch, * that will cause the IPI handler to fetch the latest * GP values as if an IPI was sent by the other side. */ - if (ret == xpcTimeout) { + if (ret == xpTimeout) { xpc_IPI_send_local_msgrequest(ch); } if (flags & XPC_NOWAIT) { xpc_msgqueue_deref(ch); - return xpcNoWait; + return xpNoWait; } ret = xpc_allocate_msg_wait(ch); - if (ret != xpcInterrupted && ret != xpcTimeout) { + if (ret != xpInterrupted && ret != xpTimeout) { xpc_msgqueue_deref(ch); return ret; } @@ -1808,13 +1799,13 @@ xpc_allocate_msg(struct xpc_channel *ch, DBUG_ON(msg->flags != 0); msg->number = put; - dev_dbg(xpc_chan, "w_local_GP.put changed to %ld; msg=0x%p, " - "msg_number=%ld, partid=%d, channel=%d\n", put + 1, + 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); *address_of_msg = msg; - return xpcSuccess; + return xpSuccess; } @@ -1829,17 +1820,17 @@ xpc_allocate_msg(struct xpc_channel *ch, * ch_number - channel #. * flags - see xpc.h for valid flags. * payload - address of the allocated payload area pointer (filled in on - * return) in which the user-defined message is constructed. + * return) in which the user-defined message is constructed. */ -enum xpc_retval -xpc_initiate_allocate(partid_t partid, int ch_number, u32 flags, void **payload) +enum xp_retval +xpc_initiate_allocate(short partid, int ch_number, u32 flags, void **payload) { struct xpc_partition *part = &xpc_partitions[partid]; - enum xpc_retval ret = xpcUnknownReason; + enum xp_retval ret = xpUnknownReason; struct xpc_msg *msg = NULL; - DBUG_ON(partid <= 0 || partid >= XP_MAX_PARTITIONS); + DBUG_ON(partid < XP_MIN_PARTID || partid > XP_MAX_PARTID); DBUG_ON(ch_number < 0 || ch_number >= part->nchannels); *payload = NULL; @@ -1901,8 +1892,8 @@ xpc_send_msgs(struct xpc_channel *ch, s6 /* we just set the new value of local_GP->put */ - dev_dbg(xpc_chan, "local_GP->put changed to %ld, partid=%d, " - "channel=%d\n", put, ch->partid, ch->number); + dev_dbg(xpc_chan, "local_GP->put changed to %" U64_ELL "d, " + "partid=%d, channel=%d\n", put, ch->partid, ch->number); send_IPI = 1; @@ -1925,11 +1916,11 @@ xpc_send_msgs(struct xpc_channel *ch, s6 * local message queue's Put value and sends an IPI to the partition the * message is being sent to. */ -static enum xpc_retval +static enum xp_retval xpc_send_msg(struct xpc_channel *ch, struct xpc_msg *msg, u8 notify_type, xpc_notify_func func, void *key) { - enum xpc_retval ret = xpcSuccess; + enum xp_retval ret = xpSuccess; struct xpc_notify *notify = notify; s64 put, msg_number = msg->number; @@ -1959,7 +1950,7 @@ xpc_send_msg(struct xpc_channel *ch, str notify->key = key; notify->type = notify_type; - // >>> is a mb() needed here? + /* >>> is a mb() needed here? */ if (ch->flags & XPC_C_DISCONNECTING) { /* @@ -2022,18 +2013,18 @@ xpc_send_msg(struct xpc_channel *ch, str * payload - pointer to the payload area allocated via * xpc_initiate_allocate(). */ -enum xpc_retval -xpc_initiate_send(partid_t partid, int ch_number, void *payload) +enum xp_retval +xpc_initiate_send(short partid, int ch_number, void *payload) { struct xpc_partition *part = &xpc_partitions[partid]; struct xpc_msg *msg = XPC_MSG_ADDRESS(payload); - enum xpc_retval ret; + enum xp_retval ret; dev_dbg(xpc_chan, "msg=0x%p, partid=%d, channel=%d\n", (void *) msg, partid, ch_number); - DBUG_ON(partid <= 0 || partid >= XP_MAX_PARTITIONS); + DBUG_ON(partid < XP_MIN_PARTID || partid > XP_MAX_PARTID); DBUG_ON(ch_number < 0 || ch_number >= part->nchannels); DBUG_ON(msg == NULL); @@ -2073,19 +2064,19 @@ xpc_initiate_send(partid_t partid, int c * receipt. THIS FUNCTION MUST BE NON-BLOCKING. * key - user-defined key to be passed to the function when it's called. */ -enum xpc_retval -xpc_initiate_send_notify(partid_t partid, int ch_number, void *payload, +enum xp_retval +xpc_initiate_send_notify(short partid, int ch_number, void *payload, xpc_notify_func func, void *key) { struct xpc_partition *part = &xpc_partitions[partid]; struct xpc_msg *msg = XPC_MSG_ADDRESS(payload); - enum xpc_retval ret; + enum xp_retval ret; dev_dbg(xpc_chan, "msg=0x%p, partid=%d, channel=%d\n", (void *) msg, partid, ch_number); - DBUG_ON(partid <= 0 || partid >= XP_MAX_PARTITIONS); + DBUG_ON(partid < XP_MIN_PARTID || partid > XP_MAX_PARTID); DBUG_ON(ch_number < 0 || ch_number >= part->nchannels); DBUG_ON(msg == NULL); DBUG_ON(func == NULL); @@ -2103,7 +2094,7 @@ xpc_pull_remote_msg(struct xpc_channel * struct xpc_msg *remote_msg, *msg; u32 msg_index, nmsgs; u64 msg_offset; - enum xpc_retval ret; + enum xp_retval ret; if (mutex_lock_interruptible(&ch->msg_to_pull_mutex) != 0) { @@ -2133,12 +2124,13 @@ xpc_pull_remote_msg(struct xpc_channel * msg_offset); if ((ret = xpc_pull_remote_cachelines(part, msg, remote_msg, - nmsgs * ch->msg_size)) != xpcSuccess) { + nmsgs * ch->msg_size)) != xpSuccess) { dev_dbg(xpc_chan, "failed to pull %d msgs starting with" - " msg %ld from partition %d, channel=%d, " - "ret=%d\n", nmsgs, ch->next_msg_to_pull, - ch->partid, ch->number, ret); + " msg %" U64_ELL "d from partition %d, " + "channel=%d, ret=%d\n", nmsgs, + ch->next_msg_to_pull, ch->partid, ch->number, + ret); XPC_DEACTIVATE_PARTITION(part, ret); @@ -2186,13 +2178,13 @@ 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 */ - dev_dbg(xpc_chan, "w_local_GP.get changed to %ld, " - "partid=%d, channel=%d\n", get + 1, + dev_dbg(xpc_chan, "w_local_GP.get changed to %" U64_ELL + "d, partid=%d, channel=%d\n", get + 1, ch->partid, ch->number); /* pull the message from the remote partition */ @@ -2234,18 +2226,18 @@ xpc_deliver_msg(struct xpc_channel *ch) if (ch->func != NULL) { dev_dbg(xpc_chan, "ch->func() called, msg=0x%p, " - "msg_number=%ld, partid=%d, channel=%d\n", - (void *) msg, msg->number, ch->partid, - ch->number); + "msg_number=%" U64_ELL "d, partid=%d, " + "channel=%d\n", (void *) msg, msg->number, + ch->partid, ch->number); /* deliver the message to its intended recipient */ - ch->func(xpcMsgReceived, ch->partid, ch->number, + ch->func(xpMsgReceived, ch->partid, ch->number, &msg->payload, ch->key); dev_dbg(xpc_chan, "ch->func() returned, msg=0x%p, " - "msg_number=%ld, partid=%d, channel=%d\n", - (void *) msg, msg->number, ch->partid, - ch->number); + "msg_number=%" U64_ELL "d, partid=%d, " + "channel=%d\n", (void *) msg, msg->number, + ch->partid, ch->number); } atomic_dec(&ch->kthreads_active); @@ -2299,8 +2291,8 @@ xpc_acknowledge_msgs(struct xpc_channel /* we just set the new value of local_GP->get */ - dev_dbg(xpc_chan, "local_GP->get changed to %ld, partid=%d, " - "channel=%d\n", get, ch->partid, ch->number); + dev_dbg(xpc_chan, "local_GP->get changed to %" U64_ELL "d, " + "partid=%d, channel=%d\n", get, ch->partid, ch->number); send_IPI = (msg_flags & XPC_M_INTERRUPT); @@ -2336,7 +2328,7 @@ xpc_acknowledge_msgs(struct xpc_channel * xpc_initiate_allocate(). */ void -xpc_initiate_received(partid_t partid, int ch_number, void *payload) +xpc_initiate_received(short partid, int ch_number, void *payload) { struct xpc_partition *part = &xpc_partitions[partid]; struct xpc_channel *ch; @@ -2344,13 +2336,14 @@ xpc_initiate_received(partid_t partid, i s64 get, msg_number = msg->number; - DBUG_ON(partid <= 0 || partid >= XP_MAX_PARTITIONS); + 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=%ld, partid=%d, channel=%d\n", - (void *) msg, msg_number, ch->partid, 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, + ch->number); DBUG_ON((((u64) msg - (u64) ch->remote_msgqueue) / ch->msg_size) != msg_number % ch->remote_nentries); Index: linux-2.6/drivers/misc/xp/xpc_main.c =================================================================== --- linux-2.6.orig/drivers/misc/xp/xpc_main.c 2008-03-26 10:40:03.160341945 -0500 +++ linux-2.6/drivers/misc/xp/xpc_main.c 2008-03-26 10:41:52.361645910 -0500 @@ -3,7 +3,7 @@ * License. See the file "COPYING" in the main directory of this archive * for more details. * - * Copyright (c) 2004-2007 Silicon Graphics, Inc. All Rights Reserved. + * Copyright (c) 2004-2008 Silicon Graphics, Inc. All Rights Reserved. */ @@ -56,10 +56,16 @@ #include #include #include -#include -#include +#if defined(CONFIG_IA64) +#include +#include +#elif defined(CONFIG_X86_64) +#define rtc_time() 1 /* will deal with this on X86_64 shortly */ +#else +#error architecture is NOT supported +#endif #include -#include +#include "xpc.h" /* define two XPC debug device structures to be used with dev_dbg() et al */ @@ -101,7 +107,7 @@ static int xpc_disengage_request_max_tim static ctl_table xpc_sys_xpc_hb_dir[] = { { - .ctl_name = CTL_UNNUMBERED, + .ctl_name = CTL_UNNUMBERED, .procname = "hb_interval", .data = &xpc_hb_interval, .maxlen = sizeof(int), @@ -204,7 +210,7 @@ xpc_timeout_partition_disengage_request( (void) xpc_partition_disengaged(part); DBUG_ON(part->disengage_request_timeout != 0); - DBUG_ON(xpc_partition_engaged(1UL << XPC_PARTID(part)) != 0); + DBUG_ON(xpc_partition_engaged(XPC_PARTID(part)) != 0); } @@ -343,14 +349,14 @@ xpc_initiate_discovery(void *ignore) * the XPC per partition variables from the remote partition and waiting for * the remote partition to pull ours. */ -static enum xpc_retval +static enum xp_retval xpc_make_first_contact(struct xpc_partition *part) { - enum xpc_retval ret; + enum xp_retval ret; - while ((ret = xpc_pull_remote_vars_part(part)) != xpcSuccess) { - if (ret != xpcRetry) { + while ((ret = xpc_pull_remote_vars_part(part)) != xpSuccess) { + if (ret != xpRetry) { XPC_DEACTIVATE_PARTITION(part, ret); return ret; } @@ -361,7 +367,7 @@ xpc_make_first_contact(struct xpc_partit /* wait a 1/4 of a second or so */ (void) msleep_interruptible(250); - if (part->act_state == XPC_P_DEACTIVATING) { + if (part->act_state == XPC_P_AS_DEACTIVATING) { return part->reason; } } @@ -385,7 +391,7 @@ xpc_make_first_contact(struct xpc_partit static void xpc_channel_mgr(struct xpc_partition *part) { - while (part->act_state != XPC_P_DEACTIVATING || + while (part->act_state != XPC_P_AS_DEACTIVATING || atomic_read(&part->nchannels_active) > 0 || !xpc_partition_disengaged(part)) { @@ -410,13 +416,10 @@ xpc_channel_mgr(struct xpc_partition *pa (atomic_read(&part->channel_mgr_requests) > 0 || (volatile u64) part->local_IPI_amo != 0 || ((volatile u8) part->act_state == - XPC_P_DEACTIVATING && + XPC_P_AS_DEACTIVATING && atomic_read(&part->nchannels_active) == 0 && xpc_partition_disengaged(part)))); atomic_set(&part->channel_mgr_requests, 1); - - // >>> Does it need to wakeup periodically as well? In case we - // >>> miscalculated the #of kthreads to wakeup or create? } } @@ -443,7 +446,7 @@ xpc_partition_up(struct xpc_partition *p dev_dbg(xpc_chan, "activating partition %d\n", XPC_PARTID(part)); - if (xpc_setup_infrastructure(part) != xpcSuccess) { + if (xpc_setup_infrastructure(part) != xpSuccess) { return; } @@ -456,7 +459,7 @@ xpc_partition_up(struct xpc_partition *p (void) xpc_part_ref(part); /* this will always succeed */ - if (xpc_make_first_contact(part) == xpcSuccess) { + if (xpc_make_first_contact(part) == xpSuccess) { xpc_channel_mgr(part); } @@ -469,30 +472,30 @@ xpc_partition_up(struct xpc_partition *p static int xpc_activating(void *__partid) { - partid_t 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 }; int ret; - DBUG_ON(partid <= 0 || partid >= XP_MAX_PARTITIONS); + DBUG_ON(partid < XP_MIN_PARTID || partid > XP_MAX_PARTID); - spin_lock_irqsave(&part->act_lock, irq_flags); + spin_lock_irqsave(&part->lock, irq_flags); - if (part->act_state == XPC_P_DEACTIVATING) { - part->act_state = XPC_P_INACTIVE; - spin_unlock_irqrestore(&part->act_lock, irq_flags); + if (part->act_state == XPC_P_AS_DEACTIVATING) { + part->act_state = XPC_P_AS_INACTIVE; + spin_unlock_irqrestore(&part->lock, irq_flags); part->remote_rp_pa = 0; return 0; } /* indicate the thread is activating */ - DBUG_ON(part->act_state != XPC_P_ACTIVATION_REQ); - part->act_state = XPC_P_ACTIVATING; + DBUG_ON(part->act_state != XPC_P_AS_ACTIVATION_REQ); + part->act_state = XPC_P_AS_ACTIVATING; XPC_SET_REASON(part, 0, 0); - spin_unlock_irqrestore(&part->act_lock, irq_flags); + spin_unlock_irqrestore(&part->lock, irq_flags); dev_dbg(xpc_part, "bringing partition %d up\n", partid); @@ -512,24 +515,20 @@ xpc_activating(void *__partid) set_cpus_allowed(current, CPU_MASK_ALL); /* - * Register the remote partition's AMOs with SAL so it can handle - * and cleanup errors within that address range should the remote - * partition go down. We don't unregister this range because it is - * difficult to tell when outstanding writes to the remote partition - * are finished and thus when it is safe to unregister. This should - * not result in wasted space in the SAL xp_addr_region table because - * we should get the same page for remote_amos_page_pa after module - * reloads and system reboots. + * 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. */ - if (sn_register_xp_addr_region(part->remote_amos_page_pa, - PAGE_SIZE, 1) < 0) { - dev_warn(xpc_part, "xpc_partition_up(%d) failed to register " - "xp_addr region\n", partid); - - spin_lock_irqsave(&part->act_lock, irq_flags); - part->act_state = XPC_P_INACTIVE; - XPC_SET_REASON(part, xpcPhysAddrRegFailed, __LINE__); - spin_unlock_irqrestore(&part->act_lock, irq_flags); + 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); + + spin_lock_irqsave(&part->lock, irq_flags); + part->act_state = XPC_P_AS_INACTIVE; + XPC_SET_REASON(part, xpPhysAddrRegFailed, __LINE__); + spin_unlock_irqrestore(&part->lock, irq_flags); part->remote_rp_pa = 0; return 0; } @@ -540,14 +539,16 @@ xpc_activating(void *__partid) /* * xpc_partition_up() holds this thread and marks this partition as - * XPC_P_ACTIVE by calling xpc_hb_mark_active(). + * XPC_P_AS_ACTIVE by calling xpc_hb_mark_active(). */ - (void) xpc_partition_up(part); + (void)xpc_partition_up(part); xpc_disallow_hb(partid, xpc_vars); xpc_mark_partition_inactive(part); - if (part->reason == xpcReactivating) { + xpc_unregister_remote_amos(part); + + if (part->reason == xpReactivating) { /* interrupting ourselves results in activating partition */ xpc_IPI_send_reactivate(part); } @@ -559,27 +560,27 @@ xpc_activating(void *__partid) void xpc_activate_partition(struct xpc_partition *part) { - partid_t partid = XPC_PARTID(part); + short partid = XPC_PARTID(part); unsigned long irq_flags; pid_t pid; - spin_lock_irqsave(&part->act_lock, irq_flags); + spin_lock_irqsave(&part->lock, irq_flags); - DBUG_ON(part->act_state != XPC_P_INACTIVE); + DBUG_ON(part->act_state != XPC_P_AS_INACTIVE); - part->act_state = XPC_P_ACTIVATION_REQ; - XPC_SET_REASON(part, xpcCloneKThread, __LINE__); + part->act_state = XPC_P_AS_ACTIVATION_REQ; + XPC_SET_REASON(part, xpCloneKThread, __LINE__); - spin_unlock_irqrestore(&part->act_lock, irq_flags); + spin_unlock_irqrestore(&part->lock, irq_flags); pid = kernel_thread(xpc_activating, (void *) ((u64) partid), 0); if (unlikely(pid <= 0)) { - spin_lock_irqsave(&part->act_lock, irq_flags); - part->act_state = XPC_P_INACTIVE; - XPC_SET_REASON(part, xpcCloneKThreadFailed, __LINE__); - spin_unlock_irqrestore(&part->act_lock, irq_flags); + spin_lock_irqsave(&part->lock, irq_flags); + part->act_state = XPC_P_AS_INACTIVE; + XPC_SET_REASON(part, xpCloneKThreadFailed, __LINE__); + spin_unlock_irqrestore(&part->lock, irq_flags); } } @@ -588,7 +589,7 @@ 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 * than one partition, we use an AMO_t structure per partition to indicate - * whether a partition has sent an IPI or not. >>> If it has, then wake up the + * whether a partition has sent an IPI or not. If it has, then wake up the * associated kthread to handle it. * * All SGI_XPC_NOTIFY IRQs received by XPC are the result of IPIs sent by XPC @@ -603,11 +604,11 @@ xpc_activate_partition(struct xpc_partit irqreturn_t xpc_notify_IRQ_handler(int irq, void *dev_id) { - partid_t partid = (partid_t) (u64) dev_id; + short partid = (short) (u64) dev_id; struct xpc_partition *part = &xpc_partitions[partid]; - DBUG_ON(partid <= 0 || partid >= XP_MAX_PARTITIONS); + DBUG_ON(partid < XP_MIN_PARTID || partid > XP_MAX_PARTID); if (xpc_part_ref(part)) { xpc_check_for_channel_activity(part); @@ -630,7 +631,7 @@ xpc_dropped_IPI_check(struct xpc_partiti xpc_check_for_channel_activity(part); part->dropped_IPI_timer.expires = jiffies + - XPC_P_DROPPED_IPI_WAIT; + XPC_DROPPED_IPI_WAIT_INTERVAL; add_timer(&part->dropped_IPI_timer); xpc_part_deref(part); } @@ -664,7 +665,6 @@ xpc_activate_kthreads(struct xpc_channel if (needed + assigned > ch->kthreads_assigned_limit) { needed = ch->kthreads_assigned_limit - assigned; - // >>>should never be less than 0 if (needed <= 0) { return; } @@ -718,7 +718,7 @@ xpc_kthread_waitmsgs(struct xpc_partitio static int xpc_daemonize_kthread(void *args) { - partid_t partid = XPC_UNPACK_ARG1(args); + short partid = XPC_UNPACK_ARG1(args); u16 ch_number = XPC_UNPACK_ARG2(args); struct xpc_partition *part = &xpc_partitions[partid]; struct xpc_channel *ch; @@ -775,7 +775,7 @@ xpc_daemonize_kthread(void *args) ch->flags |= XPC_C_DISCONNECTINGCALLOUT; spin_unlock_irqrestore(&ch->lock, irq_flags); - xpc_disconnect_callout(ch, xpcDisconnecting); + xpc_disconnect_callout(ch, xpDisconnecting); spin_lock_irqsave(&ch->lock, irq_flags); ch->flags |= XPC_C_DISCONNECTINGCALLOUT_MADE; @@ -856,8 +856,8 @@ xpc_create_kthreads(struct xpc_channel * * then we'll deadlock if all other kthreads assigned * to this channel are blocked in the channel's * registerer, because the only thing that will unblock - * them is the xpcDisconnecting callout that this - * failed kernel_thread would have made. + * them is the xpDisconnecting callout that this failed + * kernel_thread would have made. */ if (atomic_dec_return(&ch->kthreads_assigned) == 0 && @@ -876,14 +876,12 @@ xpc_create_kthreads(struct xpc_channel * * to function. */ spin_lock_irqsave(&ch->lock, irq_flags); - XPC_DISCONNECT_CHANNEL(ch, xpcLackOfResources, + XPC_DISCONNECT_CHANNEL(ch, xpLackOfResources, &irq_flags); spin_unlock_irqrestore(&ch->lock, irq_flags); } break; } - - ch->kthreads_created++; // >>> temporary debug only!!! } } @@ -892,14 +890,14 @@ void xpc_disconnect_wait(int ch_number) { unsigned long irq_flags; - partid_t partid; + short partid; struct xpc_partition *part; struct xpc_channel *ch; int wakeup_channel_mgr; /* now wait for all callouts to the caller's function to cease */ - for (partid = 1; partid < XP_MAX_PARTITIONS; partid++) { + for (partid = XP_MIN_PARTID; partid <= XP_MAX_PARTID; partid++) { part = &xpc_partitions[partid]; if (!xpc_part_ref(part)) { @@ -920,7 +918,7 @@ xpc_disconnect_wait(int ch_number) wakeup_channel_mgr = 0; if (ch->delayed_IPI_flags) { - if (part->act_state != XPC_P_DEACTIVATING) { + 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); @@ -943,9 +941,9 @@ xpc_disconnect_wait(int ch_number) static void -xpc_do_exit(enum xpc_retval reason) +xpc_do_exit(enum xp_retval reason) { - partid_t partid; + short partid; int active_part_count, printed_waiting_msg = 0; struct xpc_partition *part; unsigned long printmsg_time, disengage_request_timeout = 0; @@ -984,11 +982,13 @@ xpc_do_exit(enum xpc_retval reason) do { active_part_count = 0; - for (partid = 1; partid < XP_MAX_PARTITIONS; 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_INACTIVE) { + part->act_state == XPC_P_AS_INACTIVE) { + xpc_unregister_remote_amos(part); continue; } @@ -1003,7 +1003,7 @@ xpc_do_exit(enum xpc_retval reason) } } - if (xpc_partition_engaged(-1UL)) { + if (xpc_any_partition_engaged()) { if (time_after(jiffies, printmsg_time)) { dev_info(xpc_part, "waiting for remote " "partitions to disengage, timeout in " @@ -1035,7 +1035,7 @@ xpc_do_exit(enum xpc_retval reason) } while (1); - DBUG_ON(xpc_partition_engaged(-1UL)); + DBUG_ON(xpc_any_partition_engaged()); /* indicate to others that our reserved page is uninitialized */ @@ -1043,9 +1043,9 @@ xpc_do_exit(enum xpc_retval reason) /* now it's time to eliminate our heartbeat */ del_timer_sync(&xpc_hb_timer); - DBUG_ON(xpc_vars->heartbeating_to_mask != 0); + DBUG_ON(xpc_any_hbs_allowed(xpc_vars) != 0); - if (reason == xpcUnloading) { + if (reason == xpUnloading) { /* take ourselves off of the reboot_notifier_list */ (void) unregister_reboot_notifier(&xpc_reboot_notifier); @@ -1054,7 +1054,8 @@ xpc_do_exit(enum xpc_retval reason) } /* close down protections for IPI operations */ - xpc_restrict_IPI_ops(); + xp_disallow_IPI_ops(); + xp_change_memprotect_shub_wars_1_1(XP_MEMPROT_DISALLOW_ALL); /* clear the interface to XPC's functions */ @@ -1074,21 +1075,21 @@ xpc_do_exit(enum xpc_retval reason) static int xpc_system_reboot(struct notifier_block *nb, unsigned long event, void *unused) { - enum xpc_retval reason; + enum xp_retval reason; switch (event) { case SYS_RESTART: - reason = xpcSystemReboot; + reason = xpSystemReboot; break; case SYS_HALT: - reason = xpcSystemHalt; + reason = xpSystemHalt; break; case SYS_POWER_OFF: - reason = xpcSystemPoweroff; + reason = xpSystemPoweroff; break; default: - reason = xpcSystemGoingDown; + reason = xpSystemGoingDown; } xpc_do_exit(reason); @@ -1096,6 +1097,7 @@ xpc_system_reboot(struct notifier_block } +#ifdef CONFIG_IA64 /* * Notify other partitions to disengage from all references to our memory. */ @@ -1103,29 +1105,28 @@ static void xpc_die_disengage(void) { struct xpc_partition *part; - partid_t partid; - unsigned long engaged; + short partid; long time, printmsg_time, disengage_request_timeout; /* keep xpc_hb_checker thread from doing anything (just in case) */ xpc_exiting = 1; - xpc_vars->heartbeating_to_mask = 0; /* indicate we're deactivated */ + xpc_disallow_all_hbs(xpc_vars); /* indicate we're deactivated */ - for (partid = 1; partid < XP_MAX_PARTITIONS; partid++) { + for (partid = XP_MIN_PARTID; partid <= XP_MAX_PARTID; partid++) { part = &xpc_partitions[partid]; if (!XPC_SUPPORTS_DISENGAGE_REQUEST(part-> remote_vars_version)) { /* just in case it was left set by an earlier XPC */ - xpc_clear_partition_engaged(1UL << partid); + xpc_clear_partition_engaged(partid); continue; } - if (xpc_partition_engaged(1UL << partid) || - part->act_state != XPC_P_INACTIVE) { + if (xpc_partition_engaged(partid) || + part->act_state != XPC_P_AS_INACTIVE) { xpc_request_partition_disengage(part); xpc_mark_partition_disengaged(part); xpc_IPI_send_disengage(part); @@ -1134,23 +1135,23 @@ xpc_die_disengage(void) time = rtc_time(); printmsg_time = time + - (XPC_DISENGAGE_PRINTMSG_INTERVAL * sn_rtc_cycles_per_second); + (XPC_DISENGAGE_PRINTMSG_INTERVAL * xp_rtc_cycles_per_second); disengage_request_timeout = time + - (xpc_disengage_request_timelimit * sn_rtc_cycles_per_second); + (xpc_disengage_request_timelimit * xp_rtc_cycles_per_second); /* wait for all other partitions to disengage from us */ while (1) { - engaged = xpc_partition_engaged(-1UL); - if (!engaged) { + if (!xpc_any_partition_engaged()) { dev_info(xpc_part, "all partitions have disengaged\n"); break; } time = rtc_time(); if (time >= disengage_request_timeout) { - for (partid = 1; partid < XP_MAX_PARTITIONS; partid++) { - if (engaged & (1UL << partid)) { + for (partid = XP_MIN_PARTID; partid <= XP_MAX_PARTID; + partid++) { + if (xpc_partition_engaged(partid)) { dev_info(xpc_part, "disengage from " "remote partition %d timed " "out\n", partid); @@ -1163,13 +1164,14 @@ xpc_die_disengage(void) dev_info(xpc_part, "waiting for remote partitions to " "disengage, timeout in %ld seconds\n", (disengage_request_timeout - time) / - sn_rtc_cycles_per_second); + xp_rtc_cycles_per_second); printmsg_time = time + (XPC_DISENGAGE_PRINTMSG_INTERVAL * - sn_rtc_cycles_per_second); + xp_rtc_cycles_per_second); } } } +#endif /* CONFIG_IA64 */ /* @@ -1183,6 +1185,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 */ switch (event) { case DIE_MACHINE_RESTART: case DIE_MACHINE_HALT: @@ -1213,7 +1216,7 @@ xpc_system_die(struct notifier_block *nb xpc_vars->heartbeat_offline = 0; break; } - +#endif /* CONFIG_IA64 */ return NOTIFY_DONE; } @@ -1222,23 +1225,21 @@ int __init xpc_init(void) { int ret; - partid_t partid; + short partid; struct xpc_partition *part; pid_t pid; size_t buf_size; - - if (!ia64_platform_is("sn2")) { + if (is_shub()) { + /* + * The ia64-sn architecture supports at most 64 partitions. And + * the inability to unregister remote AMOs restricts us further + * to only support 64 partitions on this architecture. + */ + if (XP_NPARTITIONS != 64) + return -EINVAL; + } else if (!is_uv()) return -ENODEV; - } - - - buf_size = max(XPC_RP_VARS_SIZE, - XPC_RP_HEADER_SIZE + XP_NASID_MASK_BYTES); - xpc_remote_copy_buffer = xpc_kmalloc_cacheline_aligned(buf_size, - GFP_KERNEL, &xpc_remote_copy_buffer_base); - if (xpc_remote_copy_buffer == NULL) - return -ENOMEM; snprintf(xpc_part->bus_id, BUS_ID_SIZE, "part"); snprintf(xpc_chan->bus_id, BUS_ID_SIZE, "chan"); @@ -1253,14 +1254,14 @@ xpc_init(void) * ENTRIES ARE MEANINGFUL UNTIL AFTER AN ENTRY'S CORRESPONDING * PARTITION HAS BEEN ACTIVATED. */ - for (partid = 1; partid < XP_MAX_PARTITIONS; partid++) { + for (partid = XP_MIN_PARTID; partid <= XP_MAX_PARTID; partid++) { part = &xpc_partitions[partid]; DBUG_ON((u64) part != L1_CACHE_ALIGN((u64) part)); part->act_IRQ_rcvd = 0; - spin_lock_init(&part->act_lock); - part->act_state = XPC_P_INACTIVE; + spin_lock_init(&part->lock); + part->act_state = XPC_P_AS_INACTIVE; XPC_SET_REASON(part, 0, 0); init_timer(&part->disengage_request_timer); @@ -1268,7 +1269,7 @@ xpc_init(void) xpc_timeout_partition_disengage_request; part->disengage_request_timer.data = (unsigned long) part; - part->setup_state = XPC_P_UNSET; + part->setup_state = XPC_P_SS_UNSET; init_waitqueue_head(&part->teardown_wq); atomic_set(&part->references, 0); } @@ -1277,7 +1278,8 @@ xpc_init(void) * Open up protections for IPI operations (and AMO operations on * Shub 1.1 systems). */ - xpc_allow_IPI_ops(); + xp_allow_IPI_ops(); + xp_change_memprotect_shub_wars_1_1(XP_MEMPROT_ALLOW_ALL); /* * Interrupts being processed will increment this atomic variable and @@ -1297,13 +1299,13 @@ xpc_init(void) dev_err(xpc_part, "can't register ACTIVATE IRQ handler, " "errno=%d\n", -ret); - xpc_restrict_IPI_ops(); + xp_disallow_IPI_ops(); + xp_change_memprotect_shub_wars_1_1(XP_MEMPROT_DISALLOW_ALL); if (xpc_sysctl) { unregister_sysctl_table(xpc_sysctl); } - kfree(xpc_remote_copy_buffer_base); return -EBUSY; } @@ -1317,16 +1319,36 @@ xpc_init(void) dev_err(xpc_part, "could not setup our reserved page\n"); free_irq(SGI_XPC_ACTIVATE, NULL); - xpc_restrict_IPI_ops(); + xp_disallow_IPI_ops(); + xp_change_memprotect_shub_wars_1_1(XP_MEMPROT_DISALLOW_ALL); if (xpc_sysctl) { unregister_sysctl_table(xpc_sysctl); } - kfree(xpc_remote_copy_buffer_base); return -EBUSY; } + 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); + if (xpc_remote_copy_buffer == NULL) { + dev_err(xpc_part, "could not allocate remote copy buffer\n"); + + /* indicate to others that our reserved page is uninitialized */ + xpc_rsvd_page->vars_pa = 0; + + free_irq(SGI_XPC_ACTIVATE, NULL); + xp_disallow_IPI_ops(); + xp_change_memprotect_shub_wars_1_1(XP_MEMPROT_DISALLOW_ALL); + + if (xpc_sysctl) { + unregister_sysctl_table(xpc_sysctl); + } + return -ENOMEM; + } + /* add ourselves to the reboot_notifier_list */ ret = register_reboot_notifier(&xpc_reboot_notifier); @@ -1362,7 +1384,8 @@ xpc_init(void) del_timer_sync(&xpc_hb_timer); free_irq(SGI_XPC_ACTIVATE, NULL); - xpc_restrict_IPI_ops(); + xp_disallow_IPI_ops(); + xp_change_memprotect_shub_wars_1_1(XP_MEMPROT_DISALLOW_ALL); if (xpc_sysctl) { unregister_sysctl_table(xpc_sysctl); @@ -1385,7 +1408,7 @@ xpc_init(void) /* mark this new thread as a non-starter */ complete(&xpc_discovery_exited); - xpc_do_exit(xpcUnloading); + xpc_do_exit(xpUnloading); return -EBUSY; } @@ -1404,7 +1427,7 @@ module_init(xpc_init); void __exit xpc_exit(void) { - xpc_do_exit(xpcUnloading); + xpc_do_exit(xpUnloading); } module_exit(xpc_exit); Index: linux-2.6/drivers/misc/xp/xpc_partition.c =================================================================== --- linux-2.6.orig/drivers/misc/xp/xpc_partition.c 2008-03-26 10:40:03.160341945 -0500 +++ linux-2.6/drivers/misc/xp/xpc_partition.c 2008-03-26 10:40:10.689258977 -0500 @@ -3,7 +3,7 @@ * License. See the file "COPYING" in the main directory of this archive * for more details. * - * Copyright (c) 2004-2006 Silicon Graphics, Inc. All Rights Reserved. + * Copyright (c) 2004-2008 Silicon Graphics, Inc. All Rights Reserved. */ @@ -22,31 +22,21 @@ #include #include #include -#include -#include -#include -#include -#include -#include -#include +#include "xpc.h" + +#if defined(CONFIG_IA64) +#define xp_pa(_a) ia64_tpa(_a) +#elif defined(CONFIG_X86_64) +#define xp_pa(_a) __pa(_a) +#else +#error architecture is NOT supported +#endif /* XPC is exiting flag */ int xpc_exiting; -/* SH_IPI_ACCESS shub register value on startup */ -static u64 xpc_sh1_IPI_access; -static u64 xpc_sh2_IPI_access0; -static u64 xpc_sh2_IPI_access1; -static u64 xpc_sh2_IPI_access2; -static u64 xpc_sh2_IPI_access3; - - -/* original protection values for each node */ -u64 xpc_prot_vec[MAX_NUMNODES]; - - /* this partition's reserved page pointers */ struct xpc_rsvd_page *xpc_rsvd_page; static u64 *xpc_part_nasids; @@ -54,9 +44,6 @@ static u64 *xpc_mach_nasids; struct xpc_vars *xpc_vars; struct xpc_vars_part *xpc_vars_part; -static int xp_nasid_mask_bytes; /* actual size in bytes of nasid mask */ -static int xp_nasid_mask_words; /* actual size in words of nasid mask */ - /* * For performance reasons, each entry of xpc_partitions[] is cacheline @@ -64,7 +51,7 @@ static int xp_nasid_mask_words; /* actua * end so that the last legitimate entry doesn't share its cacheline with * another variable. */ -struct xpc_partition xpc_partitions[XP_MAX_PARTITIONS + 1]; +struct xpc_partition xpc_partitions[XP_NPARTITIONS + 1]; /* @@ -108,57 +95,54 @@ xpc_kmalloc_cacheline_aligned(size_t siz static u64 xpc_get_rsvd_page_pa(int nasid) { - bte_result_t bte_res; - s64 status; - u64 cookie = 0; u64 rp_pa = nasid; /* seed with nasid */ - u64 len = 0; + enum xp_retval ret; + u64 cookie = 0; + size_t len = 0; u64 buf = buf; - u64 buf_len = 0; + size_t buf_len = 0; void *buf_base = NULL; while (1) { - status = sn_partition_reserved_page_pa(buf, &cookie, &rp_pa, - &len); + ret = xp_get_partition_rsvd_page_pa(buf, &cookie, &rp_pa, &len); - dev_dbg(xpc_part, "SAL returned with status=%li, cookie=" - "0x%016lx, address=0x%016lx, len=0x%016lx\n", - status, cookie, rp_pa, len); + dev_dbg(xpc_part, "SAL returned ret=%d cookie=0x%016" U64_ELL + "x, address=0x%016" U64_ELL "x len=0x%016lx\n", ret, + cookie, rp_pa, len); - if (status != SALRET_MORE_PASSES) { + if (ret != xpNeedMoreInfo) { break; } if (L1_CACHE_ALIGN(len) > buf_len) { kfree(buf_base); buf_len = L1_CACHE_ALIGN(len); - buf = (u64) xpc_kmalloc_cacheline_aligned(buf_len, + buf = (u64)xpc_kmalloc_cacheline_aligned(buf_len, GFP_KERNEL, &buf_base); if (buf_base == NULL) { dev_err(xpc_part, "unable to kmalloc " "len=0x%016lx\n", buf_len); - status = SALRET_ERROR; + ret = xpNoMemory; break; } } - bte_res = xp_bte_copy(rp_pa, buf, buf_len, - (BTE_NOTIFY | BTE_WACQUIRE), NULL); - if (bte_res != BTE_SUCCESS) { - dev_dbg(xpc_part, "xp_bte_copy failed %i\n", bte_res); - status = SALRET_ERROR; + ret = xp_remote_memcpy((void *)buf, (void *)rp_pa, buf_len); + if (ret != xpSuccess) { + dev_dbg(xpc_part, "xp_remote_memcpy failed %d\n", ret); break; } } kfree(buf_base); - if (status != SALRET_OK) { + if (ret != xpSuccess) { rp_pa = 0; } - dev_dbg(xpc_part, "reserved page at phys address 0x%016lx\n", rp_pa); + dev_dbg(xpc_part, "reserved page at phys address 0x%016" U64_ELL "x\n", + rp_pa); return rp_pa; } @@ -172,15 +156,21 @@ struct xpc_rsvd_page * xpc_rsvd_page_init(void) { struct xpc_rsvd_page *rp; - AMO_t *amos_page; - u64 rp_pa, nasid_array = 0; - int i, ret; + int n_amos; + u64 *amos_page; + u64 rp_pa; + int i; + u64 nasid_array = 0; + int activate_irq_amos; + int engaged_partitions_amos; + int disengage_request_amos; + int ret; /* get the local reserved page's address */ preempt_disable(); - rp_pa = xpc_get_rsvd_page_pa(cpuid_to_nasid(smp_processor_id())); + rp_pa = xpc_get_rsvd_page_pa(xp_cpu_to_nasid(smp_processor_id())); preempt_enable(); if (rp_pa == 0) { dev_err(xpc_part, "SAL failed to locate the reserved page\n"); @@ -188,21 +178,14 @@ xpc_rsvd_page_init(void) } rp = (struct xpc_rsvd_page *) __va(rp_pa); - if (rp->partid != sn_partition_id) { - dev_err(xpc_part, "the reserved page's partid of %d should be " - "%d\n", rp->partid, sn_partition_id); - return NULL; - } - rp->version = XPC_RP_VERSION; /* establish the actual sizes of the nasid masks */ if (rp->SAL_version == 1) { - /* SAL_version 1 didn't set the nasids_size field */ - rp->nasids_size = 128; + /* SAL_version 1 didn't set the SAL_nasids_size field */ + rp->SAL_nasids_size = 128; } - xp_nasid_mask_bytes = rp->nasids_size; - xp_nasid_mask_words = xp_nasid_mask_bytes / 8; + xp_sizeof_nasid_mask = rp->SAL_nasids_size; /* setup the pointers to the various items in the reserved page */ xpc_part_nasids = XPC_RP_PART_NASIDS(rp); @@ -211,78 +194,70 @@ xpc_rsvd_page_init(void) xpc_vars_part = XPC_RP_VARS_PART(rp); /* - * Before clearing xpc_vars, see if a page of AMOs had been previously - * allocated. If not we'll need to allocate one and set permissions - * so that cross-partition AMOs are allowed. + * Before clearing xpc_vars, see if a page (or pages) of AMOs had been + * previously allocated. If not we'll need to allocate one (or more) + * and set permissions so that cross-partition AMOs are allowed. * - * The allocated AMO page needs MCA reporting to remain disabled after + * The allocated AMO page(s) need MCA reporting to remain disabled after * XPC has unloaded. To make this work, we keep a copy of the pointer - * to this page (i.e., amos_page) in the struct xpc_vars structure, - * which is pointed to by the reserved page, and re-use that saved copy - * on subsequent loads of XPC. This AMO page is never freed, and its - * memory protections are never restricted. + * to this page (or pages) in the struct xpc_vars structure (i.e., + * amos_page), which is pointed to by the reserved page, and re-use + * that saved copy on subsequent loads of XPC. This AMO page is never + * freed, and its memory protections are never restricted. */ if ((amos_page = xpc_vars->amos_page) == NULL) { - amos_page = (AMO_t *) TO_AMO(uncached_alloc_page(0)); + n_amos = xpc_number_of_amos(XP_NPARTITIONS); + amos_page = xp_alloc_amos(n_amos); if (amos_page == NULL) { dev_err(xpc_part, "can't allocate page of AMOs\n"); return NULL; } /* - * Open up AMO-R/W to cpu. This is done for Shub 1.1 systems - * when xpc_allow_IPI_ops() is called via xpc_hb_init(). - */ - if (!enable_shub_wars_1_1()) { - ret = sn_change_memprotect(ia64_tpa((u64) amos_page), - PAGE_SIZE, SN_MEMPROT_ACCESS_CLASS_1, - &nasid_array); - if (ret != 0) { - dev_err(xpc_part, "can't change memory " - "protections\n"); - uncached_free_page(__IA64_UNCACHED_OFFSET | - TO_PHYS((u64) amos_page)); - return NULL; - } - } - } else if (!IS_AMO_ADDRESS((u64) amos_page)) { - /* - * EFI's XPBOOT can also set amos_page in the reserved page, - * but it happens to leave it as an uncached physical address - * and we need it to be an uncached virtual, so we'll have to - * convert it. + * Open up AMO-R/W to cpu. This is done for Shub 1.1 systems + * when xp_allow_IPI_ops() is called via xpc_init(). */ - if (!IS_AMO_PHYS_ADDRESS((u64) amos_page)) { - dev_err(xpc_part, "previously used amos_page address " - "is bad = 0x%p\n", (void *) amos_page); + ret = xp_change_memprotect(xp_pa((u64)amos_page), + n_amos * xp_sizeof_amo, + XP_MEMPROT_ALLOW_CPU_AMO, + &nasid_array); + if (ret != xpSuccess) { + dev_err(xpc_part, "can't change memory protections\n"); + xp_free_amos(amos_page, n_amos); return NULL; } - amos_page = (AMO_t *) TO_AMO((u64) amos_page); } /* clear xpc_vars */ memset(xpc_vars, 0, sizeof(struct xpc_vars)); xpc_vars->version = XPC_V_VERSION; - xpc_vars->act_nasid = cpuid_to_nasid(0); + xpc_vars->partid = xp_partition_id; + xpc_vars->npartitions = XP_NPARTITIONS; + xpc_vars->act_nasid = xp_cpu_to_nasid(0); xpc_vars->act_phys_cpuid = cpu_physical_id(0); xpc_vars->vars_part_pa = __pa(xpc_vars_part); - xpc_vars->amos_page_pa = ia64_tpa((u64) amos_page); + xpc_vars->amos_page_pa = xp_pa((u64)amos_page); 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_MAX_PARTITIONS); + memset((u64 *)xpc_vars_part, 0, sizeof(struct xpc_vars_part) * + XP_NPARTITIONS); /* initialize the activate IRQ related AMO variables */ - for (i = 0; i < xp_nasid_mask_words; i++) { - (void) xpc_IPI_init(XPC_ACTIVATE_IRQ_AMOS + i); + activate_irq_amos = xpc_activate_irq_amos(XP_NPARTITIONS); + for (i = 0; i < xp_nasid_mask_words(); i++) { + (void)xpc_IPI_init(activate_irq_amos + i); } /* initialize the engaged remote partitions related AMO variables */ - (void) xpc_IPI_init(XPC_ENGAGED_PARTITIONS_AMO); - (void) xpc_IPI_init(XPC_DISENGAGE_REQUEST_AMO); + engaged_partitions_amos = xpc_engaged_partitions_amos(XP_NPARTITIONS); + disengage_request_amos = xpc_disengage_request_amos(XP_NPARTITIONS); + for (i = 0; i < xp_partid_mask_words(XP_NPARTITIONS); i++) { + (void)xpc_IPI_init(engaged_partitions_amos + i); + (void)xpc_IPI_init(disengage_request_amos + i); + } /* timestamp of when reserved page was setup by XPC */ rp->stamp = CURRENT_TIME; @@ -298,118 +273,6 @@ xpc_rsvd_page_init(void) /* - * Change protections to allow IPI operations (and AMO operations on - * Shub 1.1 systems). - */ -void -xpc_allow_IPI_ops(void) -{ - int node; - int nasid; - - - // >>> Change SH_IPI_ACCESS code to use SAL call once it is available. - - if (is_shub2()) { - xpc_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)); - xpc_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)); - - for_each_online_node(node) { - nasid = cnodeid_to_nasid(node); - HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS0), - -1UL); - HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS1), - -1UL); - HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS2), - -1UL); - HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS3), - -1UL); - } - - } else { - xpc_sh1_IPI_access = - (u64) HUB_L((u64 *) LOCAL_MMR_ADDR(SH1_IPI_ACCESS)); - - for_each_online_node(node) { - nasid = cnodeid_to_nasid(node); - HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH1_IPI_ACCESS), - -1UL); - - /* - * Since the BIST collides with memory operations on - * SHUB 1.1 sn_change_memprotect() cannot be used. - */ - if (enable_shub_wars_1_1()) { - /* open up everything */ - xpc_prot_vec[node] = (u64) HUB_L((u64 *) - GLOBAL_MMR_ADDR(nasid, - SH1_MD_DQLP_MMR_DIR_PRIVEC0)); - 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); - } - } - } -} - - -/* - * Restrict protections to disallow IPI operations (and AMO operations on - * Shub 1.1 systems). - */ -void -xpc_restrict_IPI_ops(void) -{ - int node; - int nasid; - - - // >>> Change SH_IPI_ACCESS code to use SAL call once it is available. - - if (is_shub2()) { - - for_each_online_node(node) { - nasid = cnodeid_to_nasid(node); - HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS0), - xpc_sh2_IPI_access0); - HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS1), - xpc_sh2_IPI_access1); - HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS2), - xpc_sh2_IPI_access2); - HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS3), - xpc_sh2_IPI_access3); - } - - } else { - - for_each_online_node(node) { - nasid = cnodeid_to_nasid(node); - HUB_S((u64 *) GLOBAL_MMR_ADDR(nasid, SH1_IPI_ACCESS), - xpc_sh1_IPI_access); - - if (enable_shub_wars_1_1()) { - 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]); - } - } - } -} - - -/* * At periodic intervals, scan through all active partitions and ensure * their heartbeat is still active. If not, the partition is deactivated. */ @@ -418,51 +281,49 @@ xpc_check_remote_hb(void) { struct xpc_vars *remote_vars; struct xpc_partition *part; - partid_t partid; - bte_result_t bres; + short partid; + enum xp_retval ret; remote_vars = (struct xpc_vars *) xpc_remote_copy_buffer; - for (partid = 1; partid < XP_MAX_PARTITIONS; partid++) { + for (partid = XP_MIN_PARTID; partid <= XP_MAX_PARTID; partid++) { if (xpc_exiting) { break; } - if (partid == sn_partition_id) { + if (partid == xp_partition_id) { continue; } part = &xpc_partitions[partid]; - if (part->act_state == XPC_P_INACTIVE || - part->act_state == XPC_P_DEACTIVATING) { + if (part->act_state == XPC_P_AS_INACTIVE || + part->act_state == XPC_P_AS_DEACTIVATING) { continue; } /* pull the remote_hb cache line */ - bres = xp_bte_copy(part->remote_vars_pa, - (u64) remote_vars, - XPC_RP_VARS_SIZE, - (BTE_NOTIFY | BTE_WACQUIRE), NULL); - if (bres != BTE_SUCCESS) { - XPC_DEACTIVATE_PARTITION(part, - xpc_map_bte_errors(bres)); + ret = xp_remote_memcpy(remote_vars, + (void *)part->remote_vars_pa, + XPC_RP_VARS_SIZE); + if (ret != xpSuccess) { + XPC_DEACTIVATE_PARTITION(part, ret); continue; } - dev_dbg(xpc_part, "partid = %d, heartbeat = %ld, last_heartbeat" - " = %ld, heartbeat_offline = %ld, HB_mask = 0x%lx\n", - partid, remote_vars->heartbeat, part->last_heartbeat, - remote_vars->heartbeat_offline, - remote_vars->heartbeating_to_mask); + dev_dbg(xpc_part, "partid = %d, heartbeat = %" U64_ELL "d, " + "last_heartbeat = %" U64_ELL "d, heartbeat_offline = %" + U64_ELL "d\n", partid, + remote_vars->heartbeat, part->last_heartbeat, + remote_vars->heartbeat_offline); if (((remote_vars->heartbeat == part->last_heartbeat) && (remote_vars->heartbeat_offline == 0)) || - !xpc_hb_allowed(sn_partition_id, remote_vars)) { + !xpc_hb_allowed(xp_partition_id, remote_vars)) { - XPC_DEACTIVATE_PARTITION(part, xpcNoHeartbeat); + XPC_DEACTIVATE_PARTITION(part, xpNoHeartbeat); continue; } @@ -478,27 +339,27 @@ xpc_check_remote_hb(void) * is large enough to contain a copy of their reserved page header and * part_nasids mask. */ -static enum xpc_retval +static enum xp_retval xpc_get_remote_rp(int nasid, u64 *discovered_nasids, struct xpc_rsvd_page *remote_rp, u64 *remote_rp_pa) { - int bres, i; + int i; + enum xp_retval ret; /* get the reserved page's physical address */ *remote_rp_pa = xpc_get_rsvd_page_pa(nasid); if (*remote_rp_pa == 0) { - return xpcNoRsvdPageAddr; + return xpNoRsvdPageAddr; } /* pull over the reserved page header and part_nasids mask */ - bres = xp_bte_copy(*remote_rp_pa, (u64) remote_rp, - XPC_RP_HEADER_SIZE + xp_nasid_mask_bytes, - (BTE_NOTIFY | BTE_WACQUIRE), NULL); - if (bres != BTE_SUCCESS) { - return xpc_map_bte_errors(bres); + ret = xp_remote_memcpy(remote_rp, (void *)*remote_rp_pa, + XPC_RP_HEADER_SIZE + xp_sizeof_nasid_mask); + if (ret != xpSuccess) { + return ret; } @@ -506,30 +367,17 @@ xpc_get_remote_rp(int nasid, u64 *discov u64 *remote_part_nasids = XPC_RP_PART_NASIDS(remote_rp); - for (i = 0; i < xp_nasid_mask_words; i++) { + for (i = 0; i < xp_nasid_mask_words(); i++) { discovered_nasids[i] |= remote_part_nasids[i]; } } - - /* check that the partid is for another partition */ - - if (remote_rp->partid < 1 || - remote_rp->partid > (XP_MAX_PARTITIONS - 1)) { - return xpcInvalidPartid; - } - - if (remote_rp->partid == sn_partition_id) { - return xpcLocalPartid; - } - - if (XPC_VERSION_MAJOR(remote_rp->version) != XPC_VERSION_MAJOR(XPC_RP_VERSION)) { - return xpcBadVersion; + return xpBadVersion; } - return xpcSuccess; + return xpSuccess; } @@ -539,29 +387,35 @@ xpc_get_remote_rp(int nasid, u64 *discov * remote_vars points to a buffer that is cacheline aligned for BTE copies and * assumed to be of size XPC_RP_VARS_SIZE. */ -static enum xpc_retval +static enum xp_retval xpc_get_remote_vars(u64 remote_vars_pa, struct xpc_vars *remote_vars) { - int bres; - + enum xp_retval ret; if (remote_vars_pa == 0) { - return xpcVarsNotSet; + return xpVarsNotSet; } /* pull over the cross partition variables */ - bres = xp_bte_copy(remote_vars_pa, (u64) remote_vars, XPC_RP_VARS_SIZE, - (BTE_NOTIFY | BTE_WACQUIRE), NULL); - if (bres != BTE_SUCCESS) { - return xpc_map_bte_errors(bres); + ret = xp_remote_memcpy(remote_vars, (void *)remote_vars_pa, + XPC_RP_VARS_SIZE); + if (ret != xpSuccess) { + return ret; } if (XPC_VERSION_MAJOR(remote_vars->version) != XPC_VERSION_MAJOR(XPC_V_VERSION)) { - return xpcBadVersion; + return xpBadVersion; } - return xpcSuccess; + /* check that the partid is for another partition */ + if (remote_vars->partid < XP_MIN_PARTID || + remote_vars->partid > XP_MAX_PARTID) + return xpInvalidPartid; + if (remote_vars->partid == xp_partition_id) + return xpLocalPartid; + + return xpSuccess; } @@ -582,18 +436,23 @@ xpc_update_partition_info(struct xpc_par part->remote_rp_stamp.tv_sec, part->remote_rp_stamp.tv_nsec); part->remote_rp_pa = remote_rp_pa; - dev_dbg(xpc_part, " remote_rp_pa = 0x%016lx\n", part->remote_rp_pa); + dev_dbg(xpc_part, " remote_rp_pa = 0x%016" U64_ELL "x\n", + part->remote_rp_pa); + + part->remote_npartitions = remote_vars->npartitions; + dev_dbg(xpc_part, " remote_npartitions = %d\n", + part->remote_npartitions); part->remote_vars_pa = remote_vars_pa; - dev_dbg(xpc_part, " remote_vars_pa = 0x%016lx\n", + dev_dbg(xpc_part, " remote_vars_pa = 0x%016" U64_ELL "x\n", part->remote_vars_pa); part->last_heartbeat = remote_vars->heartbeat; - dev_dbg(xpc_part, " last_heartbeat = 0x%016lx\n", + dev_dbg(xpc_part, " last_heartbeat = 0x%016" U64_ELL "x\n", part->last_heartbeat); part->remote_vars_part_pa = remote_vars->vars_part_pa; - dev_dbg(xpc_part, " remote_vars_part_pa = 0x%016lx\n", + dev_dbg(xpc_part, " remote_vars_part_pa = 0x%016" U64_ELL "x\n", part->remote_vars_part_pa); part->remote_act_nasid = remote_vars->act_nasid; @@ -605,7 +464,7 @@ xpc_update_partition_info(struct xpc_par part->remote_act_phys_cpuid); part->remote_amos_page_pa = remote_vars->amos_page_pa; - dev_dbg(xpc_part, " remote_amos_page_pa = 0x%lx\n", + dev_dbg(xpc_part, " remote_amos_page_pa = 0x%" U64_ELL "x\n", part->remote_amos_page_pa); part->remote_vars_version = remote_vars->version; @@ -639,9 +498,9 @@ xpc_identify_act_IRQ_req(int nasid) int reactivate = 0; int stamp_diff; struct timespec remote_rp_stamp = { 0, 0 }; - partid_t partid; + short partid; struct xpc_partition *part; - enum xpc_retval ret; + enum xp_retval ret; /* pull over the reserved page structure */ @@ -649,7 +508,7 @@ xpc_identify_act_IRQ_req(int nasid) remote_rp = (struct xpc_rsvd_page *) xpc_remote_copy_buffer; ret = xpc_get_remote_rp(nasid, NULL, remote_rp, &remote_rp_pa); - if (ret != xpcSuccess) { + if (ret != xpSuccess) { dev_warn(xpc_part, "unable to get reserved page from nasid %d, " "which sent interrupt, reason=%d\n", nasid, ret); return; @@ -660,40 +519,36 @@ xpc_identify_act_IRQ_req(int nasid) if (XPC_SUPPORTS_RP_STAMP(remote_rp_version)) { remote_rp_stamp = remote_rp->stamp; } - partid = remote_rp->partid; - part = &xpc_partitions[partid]; - /* pull over the cross partition variables */ remote_vars = (struct xpc_vars *) xpc_remote_copy_buffer; ret = xpc_get_remote_vars(remote_vars_pa, remote_vars); - if (ret != xpcSuccess) { - + if (ret != xpSuccess) { dev_warn(xpc_part, "unable to get XPC variables from nasid %d, " "which sent interrupt, reason=%d\n", nasid, ret); - - XPC_DEACTIVATE_PARTITION(part, ret); return; } + partid = remote_vars->partid; + part = &xpc_partitions[partid]; part->act_IRQ_rcvd++; dev_dbg(xpc_part, "partid for nasid %d is %d; IRQs = %d; HB = " - "%ld:0x%lx\n", (int) nasid, (int) partid, part->act_IRQ_rcvd, - remote_vars->heartbeat, remote_vars->heartbeating_to_mask); + "%" 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_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); if (XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version)) { - if (xpc_partition_disengage_requested(1UL << partid)) { + if (xpc_partition_disengage_requested(partid)) { /* * Other side is waiting on us to disengage, * even though we already have. @@ -702,7 +557,7 @@ xpc_identify_act_IRQ_req(int nasid) } } else { /* other side doesn't support disengage requests */ - xpc_clear_partition_disengage_request(1UL << partid); + xpc_clear_partition_disengage_request(partid); } xpc_activate_partition(part); @@ -722,7 +577,7 @@ xpc_identify_act_IRQ_req(int nasid) /* see if the other side rebooted */ if (part->remote_amos_page_pa == remote_vars->amos_page_pa && - xpc_hb_allowed(sn_partition_id, + xpc_hb_allowed(xp_partition_id, remote_vars)) { /* doesn't look that way, so ignore the IPI */ return; @@ -738,7 +593,7 @@ xpc_identify_act_IRQ_req(int nasid) &remote_rp_stamp, remote_rp_pa, remote_vars_pa, remote_vars); part->reactivate_nasid = nasid; - XPC_DEACTIVATE_PARTITION(part, xpcReactivating); + XPC_DEACTIVATE_PARTITION(part, xpReactivating); return; } @@ -752,8 +607,8 @@ xpc_identify_act_IRQ_req(int nasid) * disengage request, but the new one doesn't. */ - xpc_clear_partition_engaged(1UL << partid); - xpc_clear_partition_disengage_request(1UL << partid); + xpc_clear_partition_engaged(partid); + xpc_clear_partition_disengage_request(partid); xpc_update_partition_info(part, remote_rp_version, &remote_rp_stamp, remote_rp_pa, @@ -773,9 +628,8 @@ xpc_identify_act_IRQ_req(int nasid) * the disengage request, as does the new one. */ - DBUG_ON(xpc_partition_engaged(1UL << partid)); - DBUG_ON(xpc_partition_disengage_requested(1UL << - partid)); + DBUG_ON(xpc_partition_engaged(partid)); + DBUG_ON(xpc_partition_disengage_requested(partid)); xpc_update_partition_info(part, remote_rp_version, &remote_rp_stamp, remote_rp_pa, @@ -792,11 +646,11 @@ xpc_identify_act_IRQ_req(int nasid) if (reactivate) { part->reactivate_nasid = nasid; - XPC_DEACTIVATE_PARTITION(part, xpcReactivating); + XPC_DEACTIVATE_PARTITION(part, xpReactivating); } else if (XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version) && - xpc_partition_disengage_requested(1UL << partid)) { - XPC_DEACTIVATE_PARTITION(part, xpcOtherGoingDown); + xpc_partition_disengage_requested(partid)) { + XPC_DEACTIVATE_PARTITION(part, xpOtherGoingDown); } } @@ -811,50 +665,54 @@ xpc_identify_act_IRQ_req(int nasid) int xpc_identify_act_IRQ_sender(void) { - int word, bit; + enum xp_retval ret; + int w_index, b_index; + u64 *amo_va; u64 nasid_mask; u64 nasid; /* remote nasid */ int n_IRQs_detected = 0; - AMO_t *act_amos; - - act_amos = xpc_vars->amos_page + XPC_ACTIVATE_IRQ_AMOS; + amo_va = (u64 *)((u64)xpc_vars->amos_page + + xpc_activate_irq_amos(xpc_vars->npartitions) * + xp_sizeof_amo); - /* scan through act AMO variable looking for non-zero entries */ - for (word = 0; word < xp_nasid_mask_words; word++) { + /* scan through activation AMO variables looking for non-zero entries */ + for (w_index = 0; w_index < xp_nasid_mask_words(); w_index++) { if (xpc_exiting) { break; } - nasid_mask = xpc_IPI_receive(&act_amos[word]); + 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 */ if (nasid_mask == 0) { /* no IRQs from nasids in this variable */ continue; } - dev_dbg(xpc_part, "AMO[%d] gave back 0x%lx\n", word, - nasid_mask); + dev_dbg(xpc_part, "AMO[%d] gave back 0x%" U64_ELL "x\n", + w_index, nasid_mask); /* - * If this nasid has been added to the machine since - * our partition was reset, this will retain the - * remote nasid in our reserved pages machine mask. + * If any nasid(s) in mask have been added to the machine + * since our partition was reset, this will retain the + * remote nasid(s) in our reserved pages machine mask. * This is used in the event of module reload. */ - xpc_mach_nasids[word] |= nasid_mask; + xpc_mach_nasids[w_index] |= nasid_mask; /* locate the nasid(s) which sent interrupts */ - for (bit = 0; bit < (8 * sizeof(u64)); bit++) { - if (nasid_mask & (1UL << bit)) { + for (b_index = 0; b_index < BITS_PER_LONG; b_index++) { + if (nasid_mask & (1UL << b_index)) { n_IRQs_detected++; - nasid = XPC_NASID_FROM_W_B(word, bit); - dev_dbg(xpc_part, "interrupt from nasid %ld\n", - nasid); + nasid = (w_index * BITS_PER_LONG + b_index) * 2; + dev_dbg(xpc_part, "interrupt from nasid %" + U64_ELL "d\n", nasid); xpc_identify_act_IRQ_req(nasid); } } @@ -870,11 +728,11 @@ xpc_identify_act_IRQ_sender(void) int xpc_partition_disengaged(struct xpc_partition *part) { - partid_t partid = XPC_PARTID(part); + short partid = XPC_PARTID(part); int disengaged; - disengaged = (xpc_partition_engaged(1UL << partid) == 0); + disengaged = (xpc_partition_engaged(partid) == 0); if (part->disengage_request_timeout) { if (!disengaged) { if (jiffies < part->disengage_request_timeout) { @@ -890,7 +748,7 @@ xpc_partition_disengaged(struct xpc_part dev_info(xpc_part, "disengage from remote partition %d " "timed out\n", partid); xpc_disengage_request_timedout = 1; - xpc_clear_partition_engaged(1UL << partid); + xpc_clear_partition_engaged(partid); disengaged = 1; } part->disengage_request_timeout = 0; @@ -901,9 +759,9 @@ xpc_partition_disengaged(struct xpc_part disengage_request_timer); } - DBUG_ON(part->act_state != XPC_P_DEACTIVATING && - part->act_state != XPC_P_INACTIVE); - if (part->act_state != XPC_P_INACTIVE) { + DBUG_ON(part->act_state != XPC_P_AS_DEACTIVATING && + part->act_state != XPC_P_AS_INACTIVE); + if (part->act_state != XPC_P_AS_INACTIVE) { xpc_wakeup_channel_mgr(part); } @@ -918,24 +776,24 @@ xpc_partition_disengaged(struct xpc_part /* * Mark specified partition as active. */ -enum xpc_retval +enum xp_retval xpc_mark_partition_active(struct xpc_partition *part) { unsigned long irq_flags; - enum xpc_retval ret; + enum xp_retval ret; dev_dbg(xpc_part, "setting partition %d to ACTIVE\n", XPC_PARTID(part)); - spin_lock_irqsave(&part->act_lock, irq_flags); - if (part->act_state == XPC_P_ACTIVATING) { - part->act_state = XPC_P_ACTIVE; - ret = xpcSuccess; + spin_lock_irqsave(&part->lock, irq_flags); + if (part->act_state == XPC_P_AS_ACTIVATING) { + part->act_state = XPC_P_AS_ACTIVE; + ret = xpSuccess; } else { - DBUG_ON(part->reason == xpcSuccess); + DBUG_ON(part->reason == xpSuccess); ret = part->reason; } - spin_unlock_irqrestore(&part->act_lock, irq_flags); + spin_unlock_irqrestore(&part->lock, irq_flags); return ret; } @@ -946,35 +804,35 @@ xpc_mark_partition_active(struct xpc_par */ void xpc_deactivate_partition(const int line, struct xpc_partition *part, - enum xpc_retval reason) + enum xp_retval reason) { unsigned long irq_flags; - spin_lock_irqsave(&part->act_lock, irq_flags); + spin_lock_irqsave(&part->lock, irq_flags); - if (part->act_state == XPC_P_INACTIVE) { + if (part->act_state == XPC_P_AS_INACTIVE) { XPC_SET_REASON(part, reason, line); - spin_unlock_irqrestore(&part->act_lock, irq_flags); - if (reason == xpcReactivating) { + spin_unlock_irqrestore(&part->lock, irq_flags); + if (reason == xpReactivating) { /* we interrupt ourselves to reactivate partition */ xpc_IPI_send_reactivate(part); } return; } - if (part->act_state == XPC_P_DEACTIVATING) { - if ((part->reason == xpcUnloading && reason != xpcUnloading) || - reason == xpcReactivating) { + if (part->act_state == XPC_P_AS_DEACTIVATING) { + if ((part->reason == xpUnloading && reason != xpUnloading) || + reason == xpReactivating) { XPC_SET_REASON(part, reason, line); } - spin_unlock_irqrestore(&part->act_lock, irq_flags); + spin_unlock_irqrestore(&part->lock, irq_flags); return; } - part->act_state = XPC_P_DEACTIVATING; + part->act_state = XPC_P_AS_DEACTIVATING; XPC_SET_REASON(part, reason, line); - spin_unlock_irqrestore(&part->act_lock, irq_flags); + spin_unlock_irqrestore(&part->lock, irq_flags); if (XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version)) { xpc_request_partition_disengage(part); @@ -1007,14 +865,60 @@ xpc_mark_partition_inactive(struct xpc_p dev_dbg(xpc_part, "setting partition %d to INACTIVE\n", XPC_PARTID(part)); - spin_lock_irqsave(&part->act_lock, irq_flags); - part->act_state = XPC_P_INACTIVE; - spin_unlock_irqrestore(&part->act_lock, irq_flags); + spin_lock_irqsave(&part->lock, irq_flags); + part->act_state = XPC_P_AS_INACTIVE; + spin_unlock_irqrestore(&part->lock, irq_flags); 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. + */ +enum xp_retval +xpc_register_remote_amos(struct xpc_partition *part) +{ + unsigned long irq_flags; + size_t len; + enum xp_retval ret; + + if (part->flags & XPC_P_RAMOSREGISTERED) + return xpSuccess; + + len = xpc_number_of_amos(part->remote_npartitions) * xp_sizeof_amo; + ret = xp_register_remote_amos(part->remote_amos_page_pa, len); + if (ret == xpSuccess) { + spin_lock_irqsave(&part->lock, irq_flags); + part->flags |= XPC_P_RAMOSREGISTERED; + spin_unlock_irqrestore(&part->lock, irq_flags); + } + return ret; +} + +void +xpc_unregister_remote_amos(struct xpc_partition *part) +{ + unsigned long irq_flags; + size_t len; + enum xp_retval ret; + + if (!(part->flags & XPC_P_RAMOSREGISTERED)) + return; + + len = xpc_number_of_amos(part->remote_npartitions) * xp_sizeof_amo; + ret = xp_unregister_remote_amos(part->remote_amos_page_pa, len); + if (ret != xpSuccess) + dev_warn(xpc_part, "failed to unregister remote AMOs for " + "partition %d, ret=%d\n", XPC_PARTID(part), ret); + + spin_lock_irqsave(&part->lock, irq_flags); + part->flags &= ~XPC_P_RAMOSREGISTERED; + 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 * mask contains a bit for each even nasid in the entire machine. @@ -1036,23 +940,23 @@ xpc_discovery(void) int max_regions; int nasid; struct xpc_rsvd_page *rp; - partid_t partid; + short partid; struct xpc_partition *part; u64 *discovered_nasids; - enum xpc_retval ret; + enum xp_retval ret; remote_rp = xpc_kmalloc_cacheline_aligned(XPC_RP_HEADER_SIZE + - xp_nasid_mask_bytes, - GFP_KERNEL, &remote_rp_base); + xp_sizeof_nasid_mask, + GFP_KERNEL, &remote_rp_base); if (remote_rp == NULL) { return; } remote_vars = (struct xpc_vars *) remote_rp; - discovered_nasids = kzalloc(sizeof(u64) * xp_nasid_mask_words, - GFP_KERNEL); + discovered_nasids = kzalloc(sizeof(u64) * xp_nasid_mask_words(), + GFP_KERNEL); if (discovered_nasids == NULL) { kfree(remote_rp_base); return; @@ -1066,7 +970,7 @@ xpc_discovery(void) * protection is in regards to memory, IOI and IPI. */ max_regions = 64; - region_size = sn_region_size; + region_size = xp_region_size; switch (region_size) { case 128: @@ -1124,61 +1028,50 @@ xpc_discovery(void) ret = xpc_get_remote_rp(nasid, discovered_nasids, remote_rp, &remote_rp_pa); - if (ret != xpcSuccess) { + if (ret != xpSuccess) { dev_dbg(xpc_part, "unable to get reserved page " "from nasid %d, reason=%d\n", nasid, ret); - - if (ret == xpcLocalPartid) { - break; - } continue; } remote_vars_pa = remote_rp->vars_pa; - partid = remote_rp->partid; - part = &xpc_partitions[partid]; - - /* pull over the cross partition variables */ ret = xpc_get_remote_vars(remote_vars_pa, remote_vars); - if (ret != xpcSuccess) { + if (ret != xpSuccess) { dev_dbg(xpc_part, "unable to get XPC variables " "from nasid %d, reason=%d\n", nasid, ret); - - XPC_DEACTIVATE_PARTITION(part, ret); + if (ret == xpLocalPartid) + break; continue; } - if (part->act_state != XPC_P_INACTIVE) { + partid = remote_vars->partid; + part = &xpc_partitions[partid]; + + if (part->act_state != XPC_P_AS_INACTIVE) { dev_dbg(xpc_part, "partition %d on nasid %d is " "already activating\n", partid, nasid); break; } /* - * Register the remote partition's AMOs with SAL so it - * can handle and cleanup errors within that address - * range should the remote partition go down. We don't - * unregister this range because it is difficult to - * tell when outstanding writes to the remote partition - * are finished and thus when it is thus safe to - * unregister. This should not result in wasted space - * in the SAL xp_addr_region table because we should - * get the same page for remote_act_amos_pa after - * module reloads and system reboots. + * 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. */ - if (sn_register_xp_addr_region( - remote_vars->amos_page_pa, - PAGE_SIZE, 1) < 0) { - dev_dbg(xpc_part, "partition %d failed to " - "register xp_addr region 0x%016lx\n", - partid, remote_vars->amos_page_pa); + part->remote_npartitions = remote_vars->npartitions; + part->remote_amos_page_pa = remote_vars->amos_page_pa; + 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); - XPC_SET_REASON(part, xpcPhysAddrRegFailed, + XPC_SET_REASON(part, xpPhysAddrRegFailed, __LINE__); break; } @@ -1188,8 +1081,8 @@ xpc_discovery(void) * Send an interrupt to that nasid to notify * it that we are ready to begin activation. */ - dev_dbg(xpc_part, "sending an interrupt to AMO 0x%lx, " - "nasid %d, phys_cpuid 0x%x\n", + dev_dbg(xpc_part, "sending an interrupt to AMO 0x%" + U64_ELL "x, nasid %d, phys_cpuid 0x%x\n", remote_vars->amos_page_pa, remote_vars->act_nasid, remote_vars->act_phys_cpuid); @@ -1214,26 +1107,23 @@ xpc_discovery(void) * Given a partid, get the nasids owned by that partition from the * remote partition's reserved page. */ -enum xpc_retval -xpc_initiate_partid_to_nasids(partid_t partid, void *nasid_mask) +enum xp_retval +xpc_initiate_partid_to_nasids(short partid, void *nasid_mask) { struct xpc_partition *part; u64 part_nasid_pa; - int bte_res; part = &xpc_partitions[partid]; if (part->remote_rp_pa == 0) { - return xpcPartitionDown; + return xpPartitionDown; } - memset(nasid_mask, 0, XP_NASID_MASK_BYTES); + memset(nasid_mask, 0, xp_sizeof_nasid_mask); part_nasid_pa = (u64) XPC_RP_PART_NASIDS(part->remote_rp_pa); - bte_res = xp_bte_copy(part_nasid_pa, (u64) nasid_mask, - xp_nasid_mask_bytes, (BTE_NOTIFY | BTE_WACQUIRE), NULL); - - return xpc_map_bte_errors(bte_res); + 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-26 10:40:03.160341945 -0500 +++ linux-2.6/drivers/misc/xp/xpnet.c 2008-03-26 10:40:10.713261900 -0500 @@ -3,7 +3,7 @@ * License. See the file "COPYING" in the main directory of this archive * for more details. * - * Copyright (C) 1999,2001-2005 Silicon Graphics, Inc. All rights reserved. + * Copyright (C) 1999,2001-2008 Silicon Graphics, Inc. All rights reserved. */ @@ -33,12 +33,9 @@ #include #include #include -#include -#include -#include #include #include -#include +#include "xp.h" /* @@ -110,7 +107,6 @@ struct xpnet_message { * then be released. */ struct xpnet_pending_msg { - struct list_head free_list; struct sk_buff *skb; atomic_t use_count; }; @@ -126,7 +122,7 @@ struct net_device *xpnet_device; * When we are notified of other partitions activating, we add them to * our bitmask of partitions to which we broadcast. */ -static u64 xpnet_broadcast_partitions; +static u64 xpnet_broadcast_partitions[BITS_TO_LONGS(XP_NPARTITIONS)]; /* protect above */ static DEFINE_SPINLOCK(xpnet_broadcast_lock); @@ -147,17 +143,14 @@ static DEFINE_SPINLOCK(xpnet_broadcast_l /* - * The partition id is encapsulated in the MAC address. The following - * define locates the octet the partid is in. + * The partid is encapsulated in the MAC address beginning in the following + * octet. */ -#define XPNET_PARTID_OCTET 1 -#define XPNET_LICENSE_OCTET 2 +#define XPNET_PARTID_OCTET 2 /* consists of 2 octets total */ -/* - * Define the XPNET debug device structure that is to be used with dev_dbg(), - * dev_err(), dev_warn(), and dev_info(). - */ +/* Define the XPNET debug device structures to be used with dev_dbg() et al */ + struct device_driver xpnet_dbg_name = { .name = "xpnet" }; @@ -173,10 +166,10 @@ struct device *xpnet = &xpnet_dbg_subnam * Packet was recevied by XPC and forwarded to us. */ static void -xpnet_receive(partid_t partid, int channel, struct xpnet_message *msg) +xpnet_receive(short partid, int channel, struct xpnet_message *msg) { struct sk_buff *skb; - bte_result_t bret; + enum xp_retval ret; struct xpnet_dev_private *priv = (struct xpnet_dev_private *) xpnet_device->priv; @@ -191,8 +184,8 @@ xpnet_receive(partid_t partid, int chann return; } - dev_dbg(xpnet, "received 0x%lx, %d, %d, %d\n", msg->buf_pa, msg->size, - msg->leadin_ignore, msg->tailout_ignore); + 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 */ @@ -239,19 +232,21 @@ xpnet_receive(partid_t partid, int chann (void *)__pa((u64)skb->data & ~(L1_CACHE_BYTES - 1)), msg->size); - bret = bte_copy(msg->buf_pa, - __pa((u64)skb->data & ~(L1_CACHE_BYTES - 1)), - msg->size, (BTE_NOTIFY | BTE_WACQUIRE), NULL); - - if (bret != BTE_SUCCESS) { - // >>> Need better way of cleaning skb. Currently skb - // >>> appears in_use and we can't just call - // >>> dev_kfree_skb. - dev_err(xpnet, "bte_copy(0x%p, 0x%p, 0x%hx) returned " - "error=0x%x\n", (void *)msg->buf_pa, + ret = xp_remote_memcpy((void *)((u64)skb->data & + ~(L1_CACHE_BYTES - 1)), + (void *)msg->buf_pa, msg->size); + + if (ret != xpSuccess) { + /* + * >>> Need better way of cleaning skb. Currently skb + * >>> appears in_use and we can't just call + * >>> dev_kfree_skb. + */ + 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)), - msg->size, bret); + ~(L1_CACHE_BYTES - 1)), + (void *)msg->buf_pa, msg->size, ret); xpc_received(partid, channel, (void *) msg); @@ -290,50 +285,43 @@ xpnet_receive(partid_t partid, int chann * state or message reception on a connection. */ static void -xpnet_connection_activity(enum xpc_retval reason, partid_t partid, int channel, +xpnet_connection_activity(enum xp_retval reason, short partid, int channel, void *data, void *key) { - long bp; - - - DBUG_ON(partid <= 0 || partid >= XP_MAX_PARTITIONS); + DBUG_ON(partid < XP_MIN_PARTID || partid > XP_MAX_PARTID); DBUG_ON(channel != XPC_NET_CHANNEL); switch(reason) { - case xpcMsgReceived: /* message received */ + case xpMsgReceived: /* message received */ DBUG_ON(data == NULL); xpnet_receive(partid, channel, (struct xpnet_message *) data); break; - case xpcConnected: /* connection completed to a partition */ + case xpConnected: /* connection completed to a partition */ spin_lock_bh(&xpnet_broadcast_lock); - xpnet_broadcast_partitions |= 1UL << (partid -1 ); - bp = xpnet_broadcast_partitions; + __set_bit(partid, xpnet_broadcast_partitions); spin_unlock_bh(&xpnet_broadcast_lock); netif_carrier_on(xpnet_device); - dev_dbg(xpnet, "%s connection created to partition %d; " - "xpnet_broadcast_partitions=0x%lx\n", - xpnet_device->name, partid, bp); + dev_dbg(xpnet, "%s connected to partition %d\n", + xpnet_device->name, partid); break; default: spin_lock_bh(&xpnet_broadcast_lock); - xpnet_broadcast_partitions &= ~(1UL << (partid -1 )); - bp = xpnet_broadcast_partitions; + __clear_bit(partid, xpnet_broadcast_partitions); spin_unlock_bh(&xpnet_broadcast_lock); - if (bp == 0) { + if (bitmap_empty((unsigned long *)xpnet_broadcast_partitions, + XP_NPARTITIONS)) { netif_carrier_off(xpnet_device); } - dev_dbg(xpnet, "%s disconnected from partition %d; " - "xpnet_broadcast_partitions=0x%lx\n", - xpnet_device->name, partid, bp); + dev_dbg(xpnet, "%s disconnected from partition %d\n", + xpnet_device->name, partid); break; - } } @@ -341,18 +329,18 @@ xpnet_connection_activity(enum xpc_retva static int xpnet_dev_open(struct net_device *dev) { - enum xpc_retval ret; + enum xp_retval ret; - dev_dbg(xpnet, "calling xpc_connect(%d, 0x%p, NULL, %ld, %ld, %ld, " - "%ld)\n", XPC_NET_CHANNEL, xpnet_connection_activity, - XPNET_MSG_SIZE, XPNET_MSG_NENTRIES, XPNET_MAX_KTHREADS, - XPNET_MAX_IDLE_KTHREADS); + 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, + XPNET_MAX_KTHREADS, XPNET_MAX_IDLE_KTHREADS); ret = xpc_connect(XPC_NET_CHANNEL, xpnet_connection_activity, NULL, XPNET_MSG_SIZE, XPNET_MSG_NENTRIES, XPNET_MAX_KTHREADS, XPNET_MAX_IDLE_KTHREADS); - if (ret != xpcSuccess) { + if (ret != xpSuccess) { dev_err(xpnet, "ifconfig up of %s failed on XPC connect, " "ret=%d\n", dev->name, ret); @@ -425,7 +413,7 @@ xpnet_dev_get_stats(struct net_device *d * release the skb and then release our pending message structure. */ static void -xpnet_send_completed(enum xpc_retval reason, partid_t partid, int channel, +xpnet_send_completed(enum xp_retval reason, short partid, int channel, void *__qm) { struct xpnet_pending_msg *queued_msg = @@ -447,30 +435,67 @@ xpnet_send_completed(enum xpc_retval rea } +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) +{ + struct xpnet_message *msg; + enum xp_retval ret; + + + ret = xpc_allocate(dest_partid, XPC_NET_CHANNEL, XPC_NOWAIT, + (void **)&msg); + if (unlikely(ret != xpSuccess)) + return; + + msg->embedded_bytes = embedded_bytes; + if (unlikely(embedded_bytes != 0)) { + msg->version = XPNET_VERSION_EMBED; + dev_dbg(xpnet, "calling memcpy(0x%p, 0x%p, 0x%lx)\n", + &msg->data, skb->data, (size_t)embedded_bytes); + skb_copy_from_linear_data(skb, &msg->data, + (size_t)embedded_bytes); + } else { + msg->version = XPNET_VERSION; + } + msg->magic = XPNET_MAGIC; + msg->size = end_addr - start_addr; + msg->leadin_ignore = (u64)skb->data - start_addr; + msg->tailout_ignore = end_addr - (u64)skb_tail_pointer(skb); + msg->buf_pa = __pa(start_addr); + + dev_dbg(xpnet, "sending XPC message to %d:%d\n" + KERN_DEBUG "msg->buf_pa=0x%" U64_ELL "x, msg->size=%u, " + "msg->leadin_ignore=%u, msg->tailout_ignore=%u\n", + dest_partid, XPC_NET_CHANNEL, msg->buf_pa, msg->size, + msg->leadin_ignore, msg->tailout_ignore); + + atomic_inc(&queued_msg->use_count); + + ret = xpc_send_notify(dest_partid, XPC_NET_CHANNEL, msg, + xpnet_send_completed, queued_msg); + if (unlikely(ret != xpSuccess)) + 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 * which have connected with us and are targets of this packet. * * MAC-NOTE: For the XPNET driver, the MAC address contains the - * destination partition_id. If the destination partition id word - * is 0xff, this packet is to broadcast to all partitions. + * destination partid. If the destination partid octets are 0xffff, + * this packet is to broadcast to all connected partitions. */ static int xpnet_dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) { struct xpnet_pending_msg *queued_msg; - enum xpc_retval ret; - struct xpnet_message *msg; u64 start_addr, end_addr; - long dp; - u8 second_mac_octet; - partid_t dest_partid; - struct xpnet_dev_private *priv; - u16 embedded_bytes; - - - priv = (struct xpnet_dev_private *) dev->priv; + short dest_partid; + 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 " @@ -478,6 +503,11 @@ xpnet_dev_hard_start_xmit(struct sk_buff (void *)skb->data, skb_tail_pointer(skb), skb_end_pointer(skb), skb->len); + /* >>> What does 0x33 represent? ifconfig makes it happen */ + if (skb->data[0] == 0x33) { + dev_kfree_skb(skb); + return 0; /* nothing needed to be done */ + } /* * The xpnet_pending_msg tracks how many outstanding @@ -500,7 +530,6 @@ xpnet_dev_hard_start_xmit(struct sk_buff end_addr = L1_CACHE_ALIGN((u64)skb_tail_pointer(skb)); /* calculate how many bytes to embed in the XPC message */ - embedded_bytes = 0; if (unlikely(skb->len <= XPNET_MSG_DATA_MAX)) { /* skb->data does fit so embed */ embedded_bytes = skb->len; @@ -517,89 +546,27 @@ xpnet_dev_hard_start_xmit(struct sk_buff atomic_set(&queued_msg->use_count, 1); queued_msg->skb = skb; - - second_mac_octet = skb->data[XPNET_PARTID_OCTET]; - if (second_mac_octet == 0xff) { + if (skb->data[0] == 0xff) { /* we are being asked to broadcast to all partitions */ - dp = xpnet_broadcast_partitions; - } else if (second_mac_octet != 0) { - dp = xpnet_broadcast_partitions & - (1UL << (second_mac_octet - 1)); - } else { - /* 0 is an invalid partid. Ignore */ - dp = 0; - } - dev_dbg(xpnet, "destination Partitions mask (dp) = 0x%lx\n", dp); - - /* - * If we wanted to allow promiscuous mode to work like an - * unswitched network, this would be a good point to OR in a - * mask of partitions which should be receiving all packets. - */ - - /* - * Main send loop. - */ - for (dest_partid = 1; dp && dest_partid < XP_MAX_PARTITIONS; - dest_partid++) { - - - if (!(dp & (1UL << (dest_partid - 1)))) { - /* not destined for this partition */ - continue; - } - - /* remove this partition from the destinations mask */ - dp &= ~(1UL << (dest_partid - 1)); - - - /* found a partition to send to */ - - ret = xpc_allocate(dest_partid, XPC_NET_CHANNEL, - XPC_NOWAIT, (void **)&msg); - if (unlikely(ret != xpcSuccess)) { - continue; + for_each_bit(dest_partid, + (unsigned long *)xpnet_broadcast_partitions, + XP_NPARTITIONS) { + xpnet_send(skb, queued_msg, start_addr, end_addr, + embedded_bytes, dest_partid); } + } else { + dest_partid = (short)skb->data[XPNET_PARTID_OCTET + 1]; + dest_partid |= (short)skb->data[XPNET_PARTID_OCTET + 0] << 8; - msg->embedded_bytes = embedded_bytes; - if (unlikely(embedded_bytes != 0)) { - msg->version = XPNET_VERSION_EMBED; - dev_dbg(xpnet, "calling memcpy(0x%p, 0x%p, 0x%lx)\n", - &msg->data, skb->data, (size_t) embedded_bytes); - skb_copy_from_linear_data(skb, &msg->data, - (size_t)embedded_bytes); - } else { - msg->version = XPNET_VERSION; - } - msg->magic = XPNET_MAGIC; - msg->size = end_addr - start_addr; - msg->leadin_ignore = (u64) skb->data - start_addr; - msg->tailout_ignore = end_addr - (u64)skb_tail_pointer(skb); - msg->buf_pa = __pa(start_addr); - - dev_dbg(xpnet, "sending XPC message to %d:%d\n" - KERN_DEBUG "msg->buf_pa=0x%lx, msg->size=%u, " - "msg->leadin_ignore=%u, msg->tailout_ignore=%u\n", - dest_partid, XPC_NET_CHANNEL, msg->buf_pa, msg->size, - msg->leadin_ignore, msg->tailout_ignore); - - - atomic_inc(&queued_msg->use_count); - - ret = xpc_send_notify(dest_partid, XPC_NET_CHANNEL, msg, - xpnet_send_completed, queued_msg); - if (unlikely(ret != xpcSuccess)) { - atomic_dec(&queued_msg->use_count); - continue; + if (dest_partid >= XP_MIN_PARTID && + dest_partid <= XP_MAX_PARTID && + test_bit(dest_partid, xpnet_broadcast_partitions) != 0) { + xpnet_send(skb, queued_msg, start_addr, end_addr, + embedded_bytes, dest_partid); } - } if (atomic_dec_return(&queued_msg->use_count) == 0) { - dev_dbg(xpnet, "no partitions to receive packet destined for " - "%d\n", dest_partid); - - dev_kfree_skb(skb); kfree(queued_msg); } @@ -615,7 +582,7 @@ xpnet_dev_hard_start_xmit(struct sk_buff * Deal with transmit timeouts coming from the network layer. */ static void -xpnet_dev_tx_timeout (struct net_device *dev) +xpnet_dev_tx_timeout(struct net_device *dev) { struct xpnet_dev_private *priv; @@ -630,12 +597,11 @@ xpnet_dev_tx_timeout (struct net_device static int __init xpnet_init(void) { - int i; - u32 license_num; + short partid; int result = -ENOMEM; - if (!ia64_platform_is("sn2")) { + if (!is_shub() && !is_uv()) { return -ENODEV; } @@ -667,14 +633,12 @@ 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] = 0xfe; - xpnet_device->dev_addr[XPNET_PARTID_OCTET] = sn_partition_id; - license_num = sn_partition_serial_number_val(); - for (i = 3; i >= 0; i--) { - xpnet_device->dev_addr[XPNET_LICENSE_OCTET + i] = - license_num & 0xff; - license_num = license_num >> 8; - } + xpnet_device->dev_addr[0] = 0x02; /* locally administered, no OUI */ + + partid = xp_partition_id; + + xpnet_device->dev_addr[XPNET_PARTID_OCTET + 1] = partid & 0xff; + xpnet_device->dev_addr[XPNET_PARTID_OCTET + 0] |= (partid >> 8) & 0xff; /* * ether_setup() sets this to a multicast device. We are Index: linux-2.6/drivers/misc/xp/Makefile =================================================================== --- linux-2.6.orig/drivers/misc/xp/Makefile 2008-03-26 10:40:03.160341945 -0500 +++ linux-2.6/drivers/misc/xp/Makefile 2008-03-26 10:40:10.737264824 -0500 @@ -3,7 +3,10 @@ # obj-$(CONFIG_SGI_XP) += xp.o -xp-y := xp_main.o xp_nofault.o +xp-y := xp_main.o xp_uv.o +xp-$(CONFIG_IA64) += xp_sn2.o xp_nofault.o + obj-$(CONFIG_SGI_XP) += xpc.o xpc-y := xpc_main.o xpc_channel.o xpc_partition.o + obj-$(CONFIG_SGI_XP) += xpnet.o Index: linux-2.6/drivers/misc/xp/xp_nofault.S =================================================================== --- linux-2.6.orig/drivers/misc/xp/xp_nofault.S 2008-03-26 10:40:03.160341945 -0500 +++ linux-2.6/drivers/misc/xp/xp_nofault.S 2008-03-26 10:40:10.761267747 -0500 @@ -3,7 +3,7 @@ * License. See the file "COPYING" in the main directory of this archive * for more details. * - * Copyright (c) 2004-2007 Silicon Graphics, Inc. All Rights Reserved. + * Copyright (c) 2004-2008 Silicon Graphics, Inc. All Rights Reserved. */ Index: linux-2.6/include/asm-ia64/sn/bte.h =================================================================== --- linux-2.6.orig/include/asm-ia64/sn/bte.h 2008-03-26 10:40:03.160341945 -0500 +++ linux-2.6/include/asm-ia64/sn/bte.h 2008-03-26 10:40:10.789271158 -0500 @@ -3,7 +3,7 @@ * License. See the file "COPYING" in the main directory of this archive * for more details. * - * Copyright (c) 2000-2007 Silicon Graphics, Inc. All Rights Reserved. + * Copyright (c) 2000-2008 Silicon Graphics, Inc. All Rights Reserved. */ @@ -177,9 +177,6 @@ typedef enum { #define BTE_GET_ERROR_STATUS(_status) \ (BTE_SHUB2_ERROR(_status) & ~IBLS_ERROR) -#define BTE_VALID_SH2_ERROR(value) \ - ((value >= BTEFAIL_SH2_RESP_SHORT) && (value <= BTEFAIL_SH2_ALL)) - /* * Structure defining a bte. An instance of this * structure is created in the nodepda for each Index: linux-2.6/drivers/misc/xp/xp_uv.c =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ linux-2.6/drivers/misc/xp/xp_uv.c 2008-03-26 10:40:10.809273595 -0500 @@ -0,0 +1,194 @@ +/* + * This file is subject to the terms and conditions of the GNU General Public + * License. See the file "COPYING" in the main directory of this archive + * for more details. + * + * Copyright (c) 2008 Silicon Graphics, Inc. All Rights Reserved. + */ + +/* + * Cross Partition (XP) uv-based functions. + * + * Architecture specific implementation of common functions. + * + */ + +#include +#include +#include +#include "xp.h" + +extern struct device *xp; + +static enum xp_retval +xp_register_nofault_code_uv(void) +{ + return xpSuccess; +} + +static void +xp_unregister_nofault_code_uv(void) +{ +} + +static enum xp_retval +xp_remote_memcpy_uv(void *vdst, const void *psrc, size_t len) +{ + /* >>> this function needs fleshing out */ + return xpUnsupported; +} + +static enum xp_retval +xp_register_remote_amos_uv(u64 paddr, size_t len) +{ + /* >>> this function needs fleshing out */ + return xpUnsupported; +} + +static enum xp_retval +xp_unregister_remote_amos_uv(u64 paddr, size_t len) +{ + /* >>> this function needs fleshing out */ + return xpUnsupported; +} + +/* + * Allocate the required number of contiguous physical pages to hold the + * specified number of AMOs. + */ +static u64 * +xp_alloc_amos_uv(int n_amos) +{ + size_t n_bytes = roundup(n_amos * xp_sizeof_amo, PAGE_SIZE); + struct page *page; + u64 *amos_page = NULL; + + page = alloc_pages_node(0, GFP_KERNEL | __GFP_ZERO | GFP_THISNODE, + get_order(n_bytes)); + if (page) + amos_page = (u64 *)page_address(page); + + return amos_page; +} + +static void +xp_free_amos_uv(u64 *amos_page, int n_amos) +{ + size_t n_bytes = roundup(n_amos * xp_sizeof_amo, PAGE_SIZE); + + free_pages((u64)amos_page, get_order(n_bytes)); +} + +static enum xp_retval +xp_set_amo_uv(u64 *amo_va, int op, u64 operand, int remote) +{ + /* >>> this function needs fleshing out */ + return xpUnsupported; +} + +static enum xp_retval +xp_set_amo_with_interrupt_uv(u64 *amo_va, int op, u64 operand, int remote, + int nasid, int phys_cpuid, int vector) +{ + /* >>> this function needs fleshing out */ + return xpUnsupported; +} + +static enum xp_retval +xp_get_amo_uv(u64 *amo_va, int op, u64 *amo_value_addr) +{ + /* >>> this function needs fleshing out */ + return xpUnsupported; +} + +static enum xp_retval +xp_get_partition_rsvd_page_pa_uv(u64 buf, u64 *cookie, u64 *paddr, size_t *len) +{ + /* >>> this function needs fleshing out */ + return xpUnsupported; +} + +static enum xp_retval +xp_change_memprotect_uv(u64 paddr, size_t len, int request, u64 *nasid_array) +{ + /* >>> this function needs fleshing out */ + return xpUnsupported; +} + +static void +xp_change_memprotect_shub_wars_1_1_uv(int request) +{ + return; +} + +static void +xp_allow_IPI_ops_uv(void) +{ + /* >>> this function needs fleshing out */ + return; +} + +static void +xp_disallow_IPI_ops_uv(void) +{ + /* >>> this function needs fleshing out */ + return; +} + +static int +xp_cpu_to_nasid_uv(int cpuid) +{ + /* >>> this function needs fleshing out */ + return -1; +} + +static int +xp_node_to_nasid_uv(int nid) +{ + /* >>> this function needs fleshing out */ + return -1; +} + +enum xp_retval +xp_init_uv(void) +{ + BUG_ON(!is_uv()); + + 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; + + xp_register_remote_amos = xp_register_remote_amos_uv; + xp_unregister_remote_amos = xp_unregister_remote_amos_uv; + + xp_sizeof_amo = sizeof(u64); + xp_alloc_amos = xp_alloc_amos_uv; + xp_free_amos = xp_free_amos_uv; + xp_set_amo = xp_set_amo_uv; + xp_set_amo_with_interrupt = xp_set_amo_with_interrupt_uv; + xp_get_amo = xp_get_amo_uv; + + xp_get_partition_rsvd_page_pa = xp_get_partition_rsvd_page_pa_uv; + + xp_change_memprotect = xp_change_memprotect_uv; + xp_change_memprotect_shub_wars_1_1 = + 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; + + xp_cpu_to_nasid = xp_cpu_to_nasid_uv; + xp_node_to_nasid = xp_node_to_nasid_uv; + + return xp_register_nofault_code_uv(); +} + +void +xp_exit_uv(void) +{ + BUG_ON(!is_uv()); + + xp_unregister_nofault_code_uv(); +} + Index: linux-2.6/arch/ia64/sn/kernel/setup.c =================================================================== --- linux-2.6.orig/arch/ia64/sn/kernel/setup.c 2008-03-26 10:40:03.164342433 -0500 +++ linux-2.6/arch/ia64/sn/kernel/setup.c 2008-03-26 10:40:10.833276518 -0500 @@ -3,7 +3,7 @@ * License. See the file "COPYING" in the main directory of this archive * for more details. * - * Copyright (C) 1999,2001-2006 Silicon Graphics, Inc. All rights reserved. + * Copyright (C) 1999,2001-2008 Silicon Graphics, Inc. All rights reserved. */ #include @@ -93,7 +93,7 @@ u8 sn_region_size; EXPORT_SYMBOL(sn_region_size); int sn_prom_type; /* 0=hardware, 1=medusa/realprom, 2=medusa/fakeprom */ -short physical_node_map[MAX_NUMALINK_NODES]; +short physical_node_map[SN_MAX_NUMALINK_NODES]; static unsigned long sn_prom_features[MAX_PROM_FEATURE_SETS]; EXPORT_SYMBOL(physical_node_map); Index: linux-2.6/include/asm-ia64/sn/arch.h =================================================================== --- linux-2.6.orig/include/asm-ia64/sn/arch.h 2008-03-26 10:40:03.164342433 -0500 +++ linux-2.6/include/asm-ia64/sn/arch.h 2008-03-26 10:40:10.857279442 -0500 @@ -5,7 +5,7 @@ * * SGI specific setup. * - * Copyright (C) 1995-1997,1999,2001-2005 Silicon Graphics, Inc. All rights reserved. + * Copyright (C) 1995-1997,1999,2001-2005,2008 Silicon Graphics, Inc. All rights reserved. * Copyright (C) 1999 Ralf Baechle (ralf@gnu.org) */ #ifndef _ASM_IA64_SN_ARCH_H @@ -42,7 +42,7 @@ * This value is also the value of the maximum number of NASIDs in the numalink * fabric. */ -#define MAX_NUMALINK_NODES 16384 +#define SN_MAX_NUMALINK_NODES 16384 /* * The following defines attributes of the HUB chip. These attributes are @@ -60,6 +60,7 @@ DECLARE_PER_CPU(struct sn_hub_info_s, __ #define sn_hub_info (&__get_cpu_var(__sn_hub_info)) #define is_shub2() (sn_hub_info->shub2) #define is_shub1() (sn_hub_info->shub2 == 0) +#define is_shub() (is_shub1() || is_shub2()) /* * Use this macro to test if shub 1.1 wars should be enabled Index: linux-2.6/drivers/misc/xp/xp_sn2.c =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ linux-2.6/drivers/misc/xp/xp_sn2.c 2008-03-26 10:42:14.804380923 -0500 @@ -0,0 +1,487 @@ +/* + * This file is subject to the terms and conditions of the GNU General Public + * License. See the file "COPYING" in the main directory of this archive + * for more details. + * + * Copyright (c) 2008 Silicon Graphics, Inc. All Rights Reserved. + */ + +/* + * Cross Partition (XP) sn2-based functions. + * + * Architecture specific implementation of common functions. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "xp.h" + +extern struct device *xp; + +/* + * Register a nofault code region which performs a cross-partition PIO read. + * If the PIO read times out, the MCA handler will consume the error and + * return to a kernel-provided instruction to indicate an error. This PIO read + * exists because it is guaranteed to timeout if the destination is down + * (AMO operations do not timeout on at least some CPUs on Shubs <= v1.2, + * which unfortunately we have to work around). + */ +static enum xp_retval +xp_register_nofault_code_sn2(void) +{ + int ret; + u64 func_addr; + u64 err_func_addr; + + func_addr = *(u64 *)xp_nofault_PIOR; + err_func_addr = *(u64 *)xp_error_PIOR; + ret = sn_register_nofault_code(func_addr, err_func_addr, err_func_addr, + 1, 1); + if (ret != 0) { + dev_err(xp, "can't register nofault code, error=%d\n", ret); + return xpSalError; + } + /* + * Setup the nofault PIO read target. (There is no special reason why + * SH_IPI_ACCESS was selected.) + */ + if (is_shub1()) + xp_nofault_PIOR_target = SH1_IPI_ACCESS; + else if (is_shub2()) + xp_nofault_PIOR_target = SH2_IPI_ACCESS0; + + return xpSuccess; +} + +void +xp_unregister_nofault_code_sn2(void) +{ + u64 func_addr = *(u64 *)xp_nofault_PIOR; + u64 err_func_addr = *(u64 *)xp_error_PIOR; + + /* unregister the PIO read nofault code region */ + (void)sn_register_nofault_code(func_addr, err_func_addr, + err_func_addr, 1, 0); +} + +/* + * Wrapper for bte_copy(). + * + * vdst - virtual address of the destination of the transfer. + * psrc - physical address of the source of the transfer. + * len - number of bytes to transfer from source to destination. + * + * Note: xp_remote_memcpy_sn2() should never be called while holding a spinlock. + */ +static enum xp_retval +xp_remote_memcpy_sn2(void *vdst, const void *psrc, size_t len) +{ + bte_result_t ret; + u64 pdst = ia64_tpa(vdst); + /* >>> What are the rules governing the src and dst addresses passed in? + * >>> Currently we're assuming that dst is a virtual address and src + * >>> is a physical address, is this appropriate? Can we allow them to + * >>> be whatever and we make the change here without damaging the + * >>> addresses? + */ + + /* + * Ensure that the physically mapped memory is contiguous. + * + * We do this by ensuring that the memory is from region 7 only. + * If the need should arise to use memory from one of the other + * regions, then modify the BUG_ON() statement to ensure that the + * memory from that region is always physically contiguous. + */ + BUG_ON(REGION_NUMBER(vdst) != RGN_KERNEL); + + ret = bte_copy((u64)psrc, pdst, len, (BTE_NOTIFY | BTE_WACQUIRE), NULL); + if (ret == BTE_SUCCESS) + return xpSuccess; + + if (is_shub2()) + dev_err(xp, "bte_copy() on shub2 failed, error=0x%x\n", ret); + else + dev_err(xp, "bte_copy() failed, error=%d\n", ret); + + return xpBteCopyError; +} + +/* + * Register the remote partition's AMOs with SAL so it can handle and cleanup + * errors within that address range should the remote partition go down. We + * don't unregister this range because it is difficult to tell when outstanding + * writes to the remote partition are finished and thus when it is safe to + * unregister. This should not result in wasted space in the SAL xp_addr_region + * table because we should get the same page for remote_amos_page_pa after + * module reloads and system reboots. + */ +static enum xp_retval +xp_register_remote_amos_sn2(u64 paddr, size_t len) +{ + enum xp_retval ret = xpSuccess; + + if (sn_register_xp_addr_region(paddr, len, 1) < 0) + ret = xpSalError; + return ret; +} + +static enum xp_retval +xp_unregister_remote_amos_sn2(u64 paddr, size_t len) +{ + return xpSuccess; /* we don't unregister AMOs on sn2 */ +} + +/* + * Allocate the required number of contiguous physical pages to hold the + * specified number of AMOs. + */ +static u64 * +xp_alloc_amos_sn2(int n_amos) +{ + int n_pages = DIV_ROUND_UP(n_amos * xp_sizeof_amo, PAGE_SIZE); + + return (u64 *)TO_AMO(uncached_alloc_page(0, n_pages)); +} + +static void +xp_free_amos_sn2(u64 *amos_page, int n_amos) +{ + int n_pages = DIV_ROUND_UP(n_amos * xp_sizeof_amo, PAGE_SIZE); + + 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 */ + int ret = xpSuccess; + /* >>> eliminate remote arg and xp_nofault_PIOR() call */ + + if (op == XP_AMO_AND) + op = FETCHOP_AND; + else if (op == XP_AMO_OR) + op = FETCHOP_OR; + else + BUG(); + + if (remote) + local_irq_save(irq_flags); + + FETCHOP_STORE_OP(TO_AMO((u64)amo_va), op, operand); + + if (remote) { + /* + * We must always use the nofault function regardless of + * whether we are on a Shub 1.1 system or a Shub 1.2 slice + * 0xc processor. If we didn't, we'd never know that the other + * partition is down and would keep sending IPIs and AMOs to + * it until the heartbeat times out. + */ + if (xp_nofault_PIOR((u64 *)GLOBAL_MMR_ADDR(NASID_GET(amo_va), + xp_nofault_PIOR_target)) != 0) + ret = xpPioReadError; + + local_irq_restore(irq_flags); + } + + return ret; +} + +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 */ + int ret = xpSuccess; + + if (op == XP_AMO_AND) + op = FETCHOP_AND; + else if (op == XP_AMO_OR) + op = FETCHOP_OR; + else + BUG(); + + if (remote) + local_irq_save(irq_flags); + + FETCHOP_STORE_OP(TO_AMO((u64)amo_va), op, operand); + sn_send_IPI_phys(nasid, phys_cpuid, vector, 0); + + if (remote) { + /* + * We must always use the nofault function regardless of + * whether we are on a Shub 1.1 system or a Shub 1.2 slice + * 0xc processor. If we didn't, we'd never know that the other + * partition is down and would keep sending IPIs and AMOs to + * it until the heartbeat times out. + */ + if (xp_nofault_PIOR((u64 *)GLOBAL_MMR_ADDR(NASID_GET(amo_va), + xp_nofault_PIOR_target)) != 0) + ret = xpPioReadError; + + local_irq_restore(irq_flags); + } + + return ret; +} + +static enum xp_retval +xp_get_amo_sn2(u64 *amo_va, int op, u64 *amo_value_addr) +{ + u64 amo_value; + + if (op == XP_AMO_LOAD) + op = FETCHOP_LOAD; + else if (op == XP_AMO_CLEAR) + op = FETCHOP_CLEAR; + else + BUG(); + + amo_value = FETCHOP_LOAD_OP(TO_AMO((u64)amo_va), op); + if (amo_value_addr != NULL) + *amo_value_addr = amo_value; + return xpSuccess; +} + +static enum xp_retval +xp_get_partition_rsvd_page_pa_sn2(u64 buf, u64 *cookie, u64 *paddr, size_t *len) +{ + s64 status; + enum xp_retval ret; + + status = sn_partition_reserved_page_pa(buf, cookie, paddr, len); + if (status == SALRET_OK) + ret = xpSuccess; + else if (status == SALRET_MORE_PASSES) + ret = xpNeedMoreInfo; + else + ret = xpSalError; + + return ret; +} + +static enum xp_retval +xp_change_memprotect_sn2(u64 paddr, size_t len, int request, u64 *nasid_array) +{ + u64 perms; + int status; + + /* + * Since the BIST collides with memory operations on + * SHUB 1.1, sn_change_memprotect() cannot be used. See + * xp_change_memprotect_shub_wars_1_1() for WAR. + */ + if (enable_shub_wars_1_1()) + return xpSuccess; + + if (request == XP_MEMPROT_DISALLOW_ALL) + perms = SN_MEMPROT_ACCESS_CLASS_0; + else if (request == XP_MEMPROT_ALLOW_CPU_AMO) + perms = SN_MEMPROT_ACCESS_CLASS_1; + else if (request == XP_MEMPROT_ALLOW_CPU_MEM) + perms = SN_MEMPROT_ACCESS_CLASS_2; + else + BUG(); + + status = sn_change_memprotect(paddr, len, perms, nasid_array); + return (status == 0) ? xpSuccess : xpSalError; +} + +/* original protection values for each node */ +static u64 xpc_prot_vec[MAX_NUMNODES]; + +/* + * Change protections to allow/disallow all operations on Shub 1.1 systems. + */ +static void +xp_change_memprotect_shub_wars_1_1_sn2(int request) +{ + int node; + int nasid; + + /* + * Since the BIST collides with memory operations on SHUB 1.1 + * sn_change_memprotect() cannot be used. + */ + if (!enable_shub_wars_1_1()) + return; + + if (request == XP_MEMPROT_ALLOW_ALL) { + for_each_online_node(node) { + 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)); + /* 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); + } + } 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]); + } + } else + BUG(); +} + +/* SH_IPI_ACCESS shub register value on startup */ +static u64 xpc_sh1_IPI_access; +static u64 xpc_sh2_IPI_access0; +static u64 xpc_sh2_IPI_access1; +static u64 xpc_sh2_IPI_access2; +static u64 xpc_sh2_IPI_access3; + +/* + * Change protections to allow IPI operations. + */ +static void +xp_allow_IPI_ops_sn2(void) +{ + int node; + int nasid; + + /* >>> The following should get moved into SAL. */ + if (is_shub2()) { + xpc_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)); + xpc_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)); + + for_each_online_node(node) { + nasid = cnodeid_to_nasid(node); + HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS0), + -1UL); + HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS1), + -1UL); + HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS2), + -1UL); + HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS3), + -1UL); + } + } else { + xpc_sh1_IPI_access = + (u64)HUB_L((u64 *)LOCAL_MMR_ADDR(SH1_IPI_ACCESS)); + + for_each_online_node(node) { + nasid = cnodeid_to_nasid(node); + HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH1_IPI_ACCESS), + -1UL); + } + } +} + +/* + * Restrict protections to disallow IPI operations. + */ +static void +xp_disallow_IPI_ops_sn2(void) +{ + int node; + int nasid; + + /* >>> The following should get moved into SAL. */ + if (is_shub2()) { + for_each_online_node(node) { + nasid = cnodeid_to_nasid(node); + HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS0), + xpc_sh2_IPI_access0); + HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS1), + xpc_sh2_IPI_access1); + HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS2), + xpc_sh2_IPI_access2); + HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH2_IPI_ACCESS3), + xpc_sh2_IPI_access3); + } + } else { + for_each_online_node(node) { + nasid = cnodeid_to_nasid(node); + HUB_S((u64 *)GLOBAL_MMR_ADDR(nasid, SH1_IPI_ACCESS), + xpc_sh1_IPI_access); + } + } +} + +static int +xp_cpu_to_nasid_sn2(int cpuid) +{ + return cpuid_to_nasid(cpuid); +} + +static int +xp_node_to_nasid_sn2(int nid) +{ + return cnodeid_to_nasid(nid); +} + +enum xp_retval +xp_init_sn2(void) +{ + BUG_ON(!is_shub()); + + xp_partition_id = sn_partition_id; + xp_region_size = sn_region_size; + xp_rtc_cycles_per_second = sn_rtc_cycles_per_second; + + xp_remote_memcpy = xp_remote_memcpy_sn2; + + xp_register_remote_amos = xp_register_remote_amos_sn2; + xp_unregister_remote_amos = xp_unregister_remote_amos_sn2; + + /* + * MSPEC based AMOs are assumed to have the important bits in only the + * first 64. The remainder is ignored other than xp_sizeof_amo must + * reflect its existence. + */ + BUG_ON(offsetof(AMO_t, variable) != 0); + 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; + xp_set_amo = xp_set_amo_sn2; + xp_set_amo_with_interrupt = xp_set_amo_with_interrupt_sn2; + xp_get_amo = xp_get_amo_sn2; + + xp_get_partition_rsvd_page_pa = xp_get_partition_rsvd_page_pa_sn2; + + xp_change_memprotect = xp_change_memprotect_sn2; + xp_change_memprotect_shub_wars_1_1 = + 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; + + xp_cpu_to_nasid = xp_cpu_to_nasid_sn2; + xp_node_to_nasid = xp_node_to_nasid_sn2; + + return xp_register_nofault_code_sn2(); +} + +void +xp_exit_sn2(void) +{ + BUG_ON(!is_shub()); + + xp_unregister_nofault_code_sn2(); +} + Index: linux-2.6/drivers/misc/Kconfig =================================================================== --- linux-2.6.orig/drivers/misc/Kconfig 2008-03-26 10:40:03.160341945 -0500 +++ linux-2.6/drivers/misc/Kconfig 2008-03-26 10:40:10.905285289 -0500 @@ -329,7 +329,7 @@ config ENCLOSURE_SERVICES config SGI_XP tristate "Support communication between SGI SSIs" - depends on IA64_GENERIC || IA64_SGI_SN2 + depends on IA64_GENERIC || IA64_SGI_SN2 || X86_64 select IA64_UNCACHED_ALLOCATOR if IA64_GENERIC || IA64_SGI_SN2 select GENERIC_ALLOCATOR if IA64_GENERIC || IA64_SGI_SN2 ---help--- -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/