[IA64] run drivers/misc/sgi-xp through scripts/checkpatch.pl (2c2b94f9) · Commits · e / devices / android_kernel_samsung_universal8890

drivers/misc/sgi-xp/xp.h

+3 −3

Original line number	Original line	Diff line number	Diff line
	@@ -79,9 +79,9 @@ xp_bte_copy(u64 src, u64 vdst, u64 len, u64 mode, void *notification)

	ret = bte_copy(src, pdst, len, mode, notification);		ret = bte_copy(src, pdst, len, mode, notification);
	if ((ret != BTE_SUCCESS) && BTE_ERROR_RETRY(ret)) {		if ((ret != BTE_SUCCESS) && BTE_ERROR_RETRY(ret)) {
	if (!in_interrupt()) {		if (!in_interrupt())
	cond_resched();		cond_resched();
	}
	ret = bte_copy(src, pdst, len, mode, notification);		ret = bte_copy(src, pdst, len, mode, notification);
	}		}

	@@ -255,7 +255,7 @@ enum xpc_retval {
	/* 115: BTE end */		/* 115: BTE end */
	xpcBteSh2End = xpcBteSh2Start + BTEFAIL_SH2_ALL,		xpcBteSh2End = xpcBteSh2Start + BTEFAIL_SH2_ALL,

	xpcUnknownReason /* 116: unknown reason -- must be last in list */		xpcUnknownReason /* 116: unknown reason - must be last in enum */
	};		};

	/*		/*

drivers/misc/sgi-xp/xp_main.c

+20 −21

Original line number	Original line	Diff line number	Diff line
	@@ -23,15 +23,21 @@
	#include "xp.h"		#include "xp.h"

	/*		/*
	* Target of nofault PIO read.		* The export of xp_nofault_PIOR needs to happen here since it is defined
			* in drivers/misc/sgi-xp/xp_nofault.S. The target of the nofault read is
			* defined here.
	*/		*/
			EXPORT_SYMBOL_GPL(xp_nofault_PIOR);

	u64 xp_nofault_PIOR_target;		u64 xp_nofault_PIOR_target;
			EXPORT_SYMBOL_GPL(xp_nofault_PIOR_target);

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

	/*		/*
	* Initialize the XPC interface to indicate that XPC isn't loaded.		* Initialize the XPC interface to indicate that XPC isn't loaded.
	@@ -52,6 +58,7 @@ struct xpc_interface xpc_interface = {
	(void ()(partid_t, int, void ))xpc_notloaded,		(void ()(partid_t, int, void ))xpc_notloaded,
	(enum xpc_retval()(partid_t, void ))xpc_notloaded		(enum xpc_retval()(partid_t, void ))xpc_notloaded
	};		};
			EXPORT_SYMBOL_GPL(xpc_interface);

	/*		/*
	* XPC calls this when it (the XPC module) has been loaded.		* XPC calls this when it (the XPC module) has been loaded.
	@@ -74,6 +81,7 @@ xpc_set_interface(void (*connect) (int),
	xpc_interface.received = received;		xpc_interface.received = received;
	xpc_interface.partid_to_nasids = partid_to_nasids;		xpc_interface.partid_to_nasids = partid_to_nasids;
	}		}
			EXPORT_SYMBOL_GPL(xpc_set_interface);

	/*		/*
	* XPC calls this when it (the XPC module) is being unloaded.		* XPC calls this when it (the XPC module) is being unloaded.
	@@ -95,6 +103,7 @@ xpc_clear_interface(void)
	xpc_interface.partid_to_nasids = (enum xpc_retval()(partid_t, void ))		xpc_interface.partid_to_nasids = (enum xpc_retval()(partid_t, void ))
	xpc_notloaded;		xpc_notloaded;
	}		}
			EXPORT_SYMBOL_GPL(xpc_clear_interface);

	/*		/*
	* Register for automatic establishment of a channel connection whenever		* Register for automatic establishment of a channel connection whenever
	@@ -133,9 +142,8 @@ xpc_connect(int ch_number, xpc_channel_func func, void *key, u16 payload_size,

	registration = &xpc_registrations[ch_number];		registration = &xpc_registrations[ch_number];

	if (mutex_lock_interruptible(&registration->mutex) != 0) {		if (mutex_lock_interruptible(&registration->mutex) != 0)
	return xpcInterrupted;		return xpcInterrupted;
	}

	/* if XPC_CHANNEL_REGISTERED(ch_number) */		/* if XPC_CHANNEL_REGISTERED(ch_number) */
	if (registration->func != NULL) {		if (registration->func != NULL) {
	@@ -157,6 +165,7 @@ xpc_connect(int ch_number, xpc_channel_func func, void *key, u16 payload_size,

	return xpcSuccess;		return xpcSuccess;
	}		}
			EXPORT_SYMBOL_GPL(xpc_connect);

	/*		/*
	* Remove the registration for automatic connection of the specified channel		* Remove the registration for automatic connection of the specified channel
	@@ -207,6 +216,7 @@ xpc_disconnect(int ch_number)

	return;		return;
	}		}
			EXPORT_SYMBOL_GPL(xpc_disconnect);

	int __init		int __init
	xp_init(void)		xp_init(void)
	@@ -215,9 +225,8 @@ xp_init(void)
	u64 func_addr = (u64 )xp_nofault_PIOR;		u64 func_addr = (u64 )xp_nofault_PIOR;
	u64 err_func_addr = (u64 )xp_error_PIOR;		u64 err_func_addr = (u64 )xp_error_PIOR;

	if (!ia64_platform_is("sn2")) {		if (!ia64_platform_is("sn2"))
	return -ENODEV;		return -ENODEV;
	}

	/*		/*
	* Register a nofault code region which performs a cross-partition		* Register a nofault code region which performs a cross-partition
	@@ -228,8 +237,9 @@ xp_init(void)
	* least some CPUs on Shubs <= v1.2, which unfortunately we have to		* least some CPUs on Shubs <= v1.2, which unfortunately we have to
	* work around).		* work around).
	*/		*/
	if ((ret = sn_register_nofault_code(func_addr, err_func_addr,		ret = sn_register_nofault_code(func_addr, err_func_addr, err_func_addr,
	err_func_addr, 1, 1)) != 0) {		1, 1);
			if (ret != 0) {
	printk(KERN_ERR "XP: can't register nofault code, error=%d\n",		printk(KERN_ERR "XP: can't register nofault code, error=%d\n",
	ret);		ret);
	}		}
	@@ -237,16 +247,14 @@ xp_init(void)
	* Setup the nofault PIO read target. (There is no special reason why		* Setup the nofault PIO read target. (There is no special reason why
	* SH_IPI_ACCESS was selected.)		* SH_IPI_ACCESS was selected.)
	*/		*/
	if (is_shub2()) {		if (is_shub2())
	xp_nofault_PIOR_target = SH2_IPI_ACCESS0;		xp_nofault_PIOR_target = SH2_IPI_ACCESS0;
	} else {		else
	xp_nofault_PIOR_target = SH1_IPI_ACCESS;		xp_nofault_PIOR_target = SH1_IPI_ACCESS;
	}

	/* initialize the connection registration mutex */		/* initialize the connection registration mutex */
	for (ch_number = 0; ch_number < XPC_NCHANNELS; ch_number++) {		for (ch_number = 0; ch_number < XPC_NCHANNELS; ch_number++)
	mutex_init(&xpc_registrations[ch_number].mutex);		mutex_init(&xpc_registrations[ch_number].mutex);
	}

	return 0;		return 0;
	}		}
	@@ -269,12 +277,3 @@ module_exit(xp_exit);
	MODULE_AUTHOR("Silicon Graphics, Inc.");		MODULE_AUTHOR("Silicon Graphics, Inc.");
	MODULE_DESCRIPTION("Cross Partition (XP) base");		MODULE_DESCRIPTION("Cross Partition (XP) base");
	MODULE_LICENSE("GPL");		MODULE_LICENSE("GPL");

	EXPORT_SYMBOL(xp_nofault_PIOR);
	EXPORT_SYMBOL(xp_nofault_PIOR_target);
	EXPORT_SYMBOL(xpc_registrations);
	EXPORT_SYMBOL(xpc_interface);
	EXPORT_SYMBOL(xpc_clear_interface);
	EXPORT_SYMBOL(xpc_set_interface);
	EXPORT_SYMBOL(xpc_connect);
	EXPORT_SYMBOL(xpc_disconnect);

drivers/misc/sgi-xp/xpc.h

+58 −66

Original line number	Original line	Diff line number	Diff line
	@@ -110,7 +110,7 @@ struct xpc_rsvd_page {
	u8 partid; /* SAL: partition ID */		u8 partid; /* SAL: partition ID */
	u8 version;		u8 version;
	u8 pad1[6]; /* align to next u64 in cacheline */		u8 pad1[6]; /* align to next u64 in cacheline */
	volatile u64 vars_pa;		u64 vars_pa; /* physical address of struct xpc_vars */
	struct timespec stamp; /* time when reserved page was setup by XPC */		struct timespec stamp; /* time when reserved page was setup by XPC */
	u64 pad2[9]; /* align to last u64 in cacheline */		u64 pad2[9]; /* align to last u64 in cacheline */
	u64 nasids_size; /* SAL: size of each nasid mask in bytes */		u64 nasids_size; /* SAL: size of each nasid mask in bytes */
	@@ -133,9 +133,10 @@ xpc_compare_stamps(struct timespec stamp1, struct timespec stamp2)
	{		{
	int ret;		int ret;

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

	@@ -224,7 +225,7 @@ xpc_disallow_hb(partid_t partid, struct xpc_vars *vars)
	* occupies half a cacheline.		* occupies half a cacheline.
	*/		*/
	struct xpc_vars_part {		struct xpc_vars_part {
	volatile u64 magic;		u64 magic;

	u64 openclose_args_pa; /* physical address of open and close args */		u64 openclose_args_pa; /* physical address of open and close args */
	u64 GPs_pa; /* physical address of Get/Put values */		u64 GPs_pa; /* physical address of Get/Put values */
	@@ -255,10 +256,12 @@ struct xpc_vars_part {
	#define XPC_RP_HEADER_SIZE L1_CACHE_ALIGN(sizeof(struct xpc_rsvd_page))		#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_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_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(_rp) ((struct xpc_vars *)(XPC_RP_MACH_NASIDS(_rp) + \
	#define XPC_RP_VARS_PART(_rp) (struct xpc_vars_part ) ((u8 ) XPC_RP_VARS(rp) + XPC_RP_VARS_SIZE)		xp_nasid_mask_words))
			#define XPC_RP_VARS_PART(_rp) ((struct xpc_vars_part *) \
			((u8 *)XPC_RP_VARS(_rp) + XPC_RP_VARS_SIZE))

	/*		/*
	* Functions registered by add_timer() or called by kernel_thread() only		* Functions registered by add_timer() or called by kernel_thread() only
	@@ -277,8 +280,8 @@ struct xpc_vars_part {
	* Define a Get/Put value pair (pointers) used with a message queue.		* Define a Get/Put value pair (pointers) used with a message queue.
	*/		*/
	struct xpc_gp {		struct xpc_gp {
	volatile s64 get; /* Get value */		s64 get; /* Get value */
	volatile s64 put; /* Put value */		s64 put; /* Put value */
	};		};

	#define XPC_GP_SIZE \		#define XPC_GP_SIZE \
	@@ -315,7 +318,7 @@ struct xpc_openclose_args {
	* and consumed by the intended recipient.		* and consumed by the intended recipient.
	*/		*/
	struct xpc_notify {		struct xpc_notify {
	volatile u8 type; /* type of notification */		u8 type; /* type of notification */

	/* the following two fields are only used if type == XPC_N_CALL */		/* the following two fields are only used if type == XPC_N_CALL */
	xpc_notify_func func; /* user's notify function */		xpc_notify_func func; /* user's notify function */
	@@ -458,16 +461,11 @@ struct xpc_channel {

	/* kthread management related fields */		/* 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 */		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 */		atomic_t kthreads_idle; /* #of kthreads idle waiting for work */
	u32 kthreads_idle_limit; /* limit on #of kthreads idle */		u32 kthreads_idle_limit; /* limit on #of kthreads idle */
	atomic_t kthreads_active; /* #of kthreads actively working */		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 */		wait_queue_head_t idle_wq; /* idle kthread wait queue */

	@@ -533,7 +531,7 @@ struct xpc_partition {

	/* XPC infrastructure referencing and teardown control */		/* XPC infrastructure referencing and teardown control */

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

	@@ -552,8 +550,8 @@ struct xpc_partition {
	void local_GPs_base; / base address of kmalloc'd space */		void local_GPs_base; / base address of kmalloc'd space */
	struct xpc_gp local_GPs; / local Get/Put values */		struct xpc_gp local_GPs; / local Get/Put values */
	void remote_GPs_base; / base address of kmalloc'd space */		void remote_GPs_base; / base address of kmalloc'd space */
	struct xpc_gp remote_GPs; / copy of remote partition's local Get/Put */		struct xpc_gp remote_GPs; / copy of remote partition's local */
	/* values */		/* Get/Put values */
	u64 remote_GPs_pa; /* phys address of remote partition's local */		u64 remote_GPs_pa; /* phys address of remote partition's local */
	/* Get/Put values */		/* Get/Put values */

	@@ -678,10 +676,9 @@ extern void xpc_teardown_infrastructure(struct xpc_partition *);
	static inline void		static inline void
	xpc_wakeup_channel_mgr(struct xpc_partition *part)		xpc_wakeup_channel_mgr(struct xpc_partition *part)
	{		{
	if (atomic_inc_return(&part->channel_mgr_requests) == 1) {		if (atomic_inc_return(&part->channel_mgr_requests) == 1)
	wake_up(&part->channel_mgr_wq);		wake_up(&part->channel_mgr_wq);
	}		}
	}

	/*		/*
	* These next two inlines are used to keep us from tearing down a channel's		* These next two inlines are used to keep us from tearing down a channel's
	@@ -699,10 +696,9 @@ xpc_msgqueue_deref(struct xpc_channel *ch)
	s32 refs = atomic_dec_return(&ch->references);		s32 refs = atomic_dec_return(&ch->references);

	DBUG_ON(refs < 0);		DBUG_ON(refs < 0);
	if (refs == 0) {		if (refs == 0)
	xpc_wakeup_channel_mgr(&xpc_partitions[ch->partid]);		xpc_wakeup_channel_mgr(&xpc_partitions[ch->partid]);
	}		}
	}

	#define XPC_DISCONNECT_CHANNEL(_ch, _reason, _irqflgs) \		#define XPC_DISCONNECT_CHANNEL(_ch, _reason, _irqflgs) \
	xpc_disconnect_channel(__LINE__, _ch, _reason, _irqflgs)		xpc_disconnect_channel(__LINE__, _ch, _reason, _irqflgs)
	@@ -717,10 +713,9 @@ xpc_part_deref(struct xpc_partition *part)
	s32 refs = atomic_dec_return(&part->references);		s32 refs = atomic_dec_return(&part->references);

	DBUG_ON(refs < 0);		DBUG_ON(refs < 0);
	if (refs == 0 && part->setup_state == XPC_P_WTEARDOWN) {		if (refs == 0 && part->setup_state == XPC_P_WTEARDOWN)
	wake_up(&part->teardown_wq);		wake_up(&part->teardown_wq);
	}		}
	}

	static inline int		static inline int
	xpc_part_ref(struct xpc_partition *part)		xpc_part_ref(struct xpc_partition *part)
	@@ -729,9 +724,9 @@ xpc_part_ref(struct xpc_partition *part)

	atomic_inc(&part->references);		atomic_inc(&part->references);
	setup = (part->setup_state == XPC_P_SETUP);		setup = (part->setup_state == XPC_P_SETUP);
	if (!setup) {		if (!setup)
	xpc_part_deref(part);		xpc_part_deref(part);
	}
	return setup;		return setup;
	}		}

	@@ -1007,16 +1002,14 @@ xpc_notify_IRQ_send(struct xpc_channel ch, u8 ipi_flag, char ipi_flag_string,
	dev_dbg(xpc_chan, "%s sent to partid=%d, channel=%d, ret=%d\n",		dev_dbg(xpc_chan, "%s sent to partid=%d, channel=%d, ret=%d\n",
	ipi_flag_string, ch->partid, ch->number, ret);		ipi_flag_string, ch->partid, ch->number, ret);
	if (unlikely(ret != xpcSuccess)) {		if (unlikely(ret != xpcSuccess)) {
	if (irq_flags != NULL) {		if (irq_flags != NULL)
	spin_unlock_irqrestore(&ch->lock, *irq_flags);		spin_unlock_irqrestore(&ch->lock, *irq_flags);
	}
	XPC_DEACTIVATE_PARTITION(part, ret);		XPC_DEACTIVATE_PARTITION(part, ret);
	if (irq_flags != NULL) {		if (irq_flags != NULL)
	spin_lock_irqsave(&ch->lock, *irq_flags);		spin_lock_irqsave(&ch->lock, *irq_flags);
	}		}
	}		}
	}		}
	}

	/*		/*
	* Make it look like the remote partition, which is associated with the		* Make it look like the remote partition, which is associated with the
	@@ -1056,8 +1049,8 @@ xpc_notify_IRQ_send_local(struct xpc_channel *ch, u8 ipi_flag,
	#define XPC_GET_IPI_FLAGS(_amo, _c) ((u8) (((_amo) >> ((_c) * 8)) & 0xff))		#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_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_OPENCLOSE_IPI_FLAGS_SET(_amo) ((_amo) & 0x0f0f0f0f0f0f0f0fUL)
	#define XPC_ANY_MSG_IPI_FLAGS_SET(_amo) ((_amo) & __IA64_UL_CONST(0x1010101010101010))		#define XPC_ANY_MSG_IPI_FLAGS_SET(_amo) ((_amo) & 0x1010101010101010UL)

	static inline void		static inline void
	xpc_IPI_send_closerequest(struct xpc_channel ch, unsigned long irq_flags)		xpc_IPI_send_closerequest(struct xpc_channel ch, unsigned long irq_flags)
	@@ -1178,9 +1171,8 @@ xpc_check_for_channel_activity(struct xpc_partition *part)
	unsigned long irq_flags;		unsigned long irq_flags;

	IPI_amo = xpc_IPI_receive(part->local_IPI_amo_va);		IPI_amo = xpc_IPI_receive(part->local_IPI_amo_va);
	if (IPI_amo == 0) {		if (IPI_amo == 0)
	return;		return;
	}

	spin_lock_irqsave(&part->IPI_lock, irq_flags);		spin_lock_irqsave(&part->IPI_lock, irq_flags);
	part->local_IPI_amo \|= IPI_amo;		part->local_IPI_amo \|= IPI_amo;

drivers/misc/sgi-xp/xpc_channel.c

+75 −117

Original line number	Original line	Diff line number	Diff line
	@@ -33,19 +33,19 @@ xpc_kzalloc_cacheline_aligned(size_t size, gfp_t flags, void **base)
	{		{
	/* see if kzalloc will give us cachline aligned memory by default */		/* see if kzalloc will give us cachline aligned memory by default */
	*base = kzalloc(size, flags);		*base = kzalloc(size, flags);
	if (*base == NULL) {		if (*base == NULL)
	return NULL;		return NULL;
	}
	if ((u64)base == L1_CACHE_ALIGN((u64)base)) {		if ((u64)base == L1_CACHE_ALIGN((u64)base))
	return *base;		return *base;
	}
	kfree(*base);		kfree(*base);

	/* nope, we'll have to do it ourselves */		/* nope, we'll have to do it ourselves */
	*base = kzalloc(size + L1_CACHE_BYTES, flags);		*base = kzalloc(size + L1_CACHE_BYTES, flags);
	if (*base == NULL) {		if (*base == NULL)
	return NULL;		return NULL;
	}
	return (void )L1_CACHE_ALIGN((u64)base);		return (void )L1_CACHE_ALIGN((u64)base);
	}		}

	@@ -264,15 +264,13 @@ xpc_pull_remote_cachelines(struct xpc_partition part, void dst,
	DBUG_ON((u64)dst != L1_CACHE_ALIGN((u64)dst));		DBUG_ON((u64)dst != L1_CACHE_ALIGN((u64)dst));
	DBUG_ON(cnt != L1_CACHE_ALIGN(cnt));		DBUG_ON(cnt != L1_CACHE_ALIGN(cnt));

	if (part->act_state == XPC_P_DEACTIVATING) {		if (part->act_state == XPC_P_DEACTIVATING)
	return part->reason;		return part->reason;
	}

	bte_ret = xp_bte_copy((u64)src, (u64)dst, (u64)cnt,		bte_ret = xp_bte_copy((u64)src, (u64)dst, (u64)cnt,
	(BTE_NORMAL \| BTE_WACQUIRE), NULL);		(BTE_NORMAL \| BTE_WACQUIRE), NULL);
	if (bte_ret == BTE_SUCCESS) {		if (bte_ret == BTE_SUCCESS)
	return xpcSuccess;		return xpcSuccess;
	}

	dev_dbg(xpc_chan, "xp_bte_copy() from partition %d failed, ret=%d\n",		dev_dbg(xpc_chan, "xp_bte_copy() from partition %d failed, ret=%d\n",
	XPC_PARTID(part), bte_ret);		XPC_PARTID(part), bte_ret);
	@@ -359,18 +357,16 @@ xpc_pull_remote_vars_part(struct xpc_partition *part)
	part->remote_IPI_nasid = pulled_entry->IPI_nasid;		part->remote_IPI_nasid = pulled_entry->IPI_nasid;
	part->remote_IPI_phys_cpuid = pulled_entry->IPI_phys_cpuid;		part->remote_IPI_phys_cpuid = pulled_entry->IPI_phys_cpuid;

	if (part->nchannels > pulled_entry->nchannels) {		if (part->nchannels > pulled_entry->nchannels)
	part->nchannels = pulled_entry->nchannels;		part->nchannels = pulled_entry->nchannels;
	}

	/* let the other side know that we've pulled their variables */		/* let the other side know that we've pulled their variables */

	xpc_vars_part[partid].magic = XPC_VP_MAGIC2;		xpc_vars_part[partid].magic = XPC_VP_MAGIC2;
	}		}

	if (pulled_entry->magic == XPC_VP_MAGIC1) {		if (pulled_entry->magic == XPC_VP_MAGIC1)
	return xpcRetry;		return xpcRetry;
	}

	return xpcSuccess;		return xpcSuccess;
	}		}
	@@ -390,9 +386,10 @@ xpc_get_IPI_flags(struct xpc_partition *part)
	*/		*/

	spin_lock_irqsave(&part->IPI_lock, irq_flags);		spin_lock_irqsave(&part->IPI_lock, irq_flags);
	if ((IPI_amo = part->local_IPI_amo) != 0) {		IPI_amo = part->local_IPI_amo;
			if (IPI_amo != 0)
	part->local_IPI_amo = 0;		part->local_IPI_amo = 0;
	}
	spin_unlock_irqrestore(&part->IPI_lock, irq_flags);		spin_unlock_irqrestore(&part->IPI_lock, irq_flags);

	if (XPC_ANY_OPENCLOSE_IPI_FLAGS_SET(IPI_amo)) {		if (XPC_ANY_OPENCLOSE_IPI_FLAGS_SET(IPI_amo)) {
	@@ -441,20 +438,14 @@ xpc_allocate_local_msgqueue(struct xpc_channel *ch)
	int nentries;		int nentries;
	size_t nbytes;		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--) {		for (nentries = ch->local_nentries; nentries > 0; nentries--) {

	nbytes = nentries * ch->msg_size;		nbytes = nentries * ch->msg_size;
	ch->local_msgqueue = xpc_kzalloc_cacheline_aligned(nbytes,		ch->local_msgqueue = xpc_kzalloc_cacheline_aligned(nbytes,
	GFP_KERNEL,		GFP_KERNEL,
	&ch->		&ch->local_msgqueue_base);
	local_msgqueue_base);		if (ch->local_msgqueue == NULL)
	if (ch->local_msgqueue == NULL) {
	continue;		continue;
	}

	nbytes = nentries * sizeof(struct xpc_notify);		nbytes = nentries * sizeof(struct xpc_notify);
	ch->notify_queue = kzalloc(nbytes, GFP_KERNEL);		ch->notify_queue = kzalloc(nbytes, GFP_KERNEL);
	@@ -493,20 +484,14 @@ xpc_allocate_remote_msgqueue(struct xpc_channel *ch)

	DBUG_ON(ch->remote_nentries <= 0);		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--) {		for (nentries = ch->remote_nentries; nentries > 0; nentries--) {

	nbytes = nentries * ch->msg_size;		nbytes = nentries * ch->msg_size;
	ch->remote_msgqueue = xpc_kzalloc_cacheline_aligned(nbytes,		ch->remote_msgqueue = xpc_kzalloc_cacheline_aligned(nbytes,
	GFP_KERNEL,		GFP_KERNEL,
	&ch->		&ch->remote_msgqueue_base);
	remote_msgqueue_base);		if (ch->remote_msgqueue == NULL)
	if (ch->remote_msgqueue == NULL) {
	continue;		continue;
	}

	spin_lock_irqsave(&ch->lock, irq_flags);		spin_lock_irqsave(&ch->lock, irq_flags);
	if (nentries < ch->remote_nentries) {		if (nentries < ch->remote_nentries) {
	@@ -538,11 +523,12 @@ xpc_allocate_msgqueues(struct xpc_channel *ch)

	DBUG_ON(ch->flags & XPC_C_SETUP);		DBUG_ON(ch->flags & XPC_C_SETUP);

	if ((ret = xpc_allocate_local_msgqueue(ch)) != xpcSuccess) {		ret = xpc_allocate_local_msgqueue(ch);
			if (ret != xpcSuccess)
	return ret;		return ret;
	}

	if ((ret = xpc_allocate_remote_msgqueue(ch)) != xpcSuccess) {		ret = xpc_allocate_remote_msgqueue(ch);
			if (ret != xpcSuccess) {
	kfree(ch->local_msgqueue_base);		kfree(ch->local_msgqueue_base);
	ch->local_msgqueue = NULL;		ch->local_msgqueue = NULL;
	kfree(ch->notify_queue);		kfree(ch->notify_queue);
	@@ -582,12 +568,11 @@ xpc_process_connect(struct xpc_channel ch, unsigned long irq_flags)
	ret = xpc_allocate_msgqueues(ch);		ret = xpc_allocate_msgqueues(ch);
	spin_lock_irqsave(&ch->lock, *irq_flags);		spin_lock_irqsave(&ch->lock, *irq_flags);

	if (ret != xpcSuccess) {		if (ret != xpcSuccess)
	XPC_DISCONNECT_CHANNEL(ch, ret, irq_flags);		XPC_DISCONNECT_CHANNEL(ch, ret, irq_flags);
	}
	if (ch->flags & (XPC_C_CONNECTED \| XPC_C_DISCONNECTING)) {		if (ch->flags & (XPC_C_CONNECTED \| XPC_C_DISCONNECTING))
	return;		return;
	}

	DBUG_ON(!(ch->flags & XPC_C_SETUP));		DBUG_ON(!(ch->flags & XPC_C_SETUP));
	DBUG_ON(ch->local_msgqueue == NULL);		DBUG_ON(ch->local_msgqueue == NULL);
	@@ -599,9 +584,8 @@ xpc_process_connect(struct xpc_channel ch, unsigned long irq_flags)
	xpc_IPI_send_openreply(ch, irq_flags);		xpc_IPI_send_openreply(ch, irq_flags);
	}		}

	if (!(ch->flags & XPC_C_ROPENREPLY)) {		if (!(ch->flags & XPC_C_ROPENREPLY))
	return;		return;
	}

	DBUG_ON(ch->remote_msgqueue_pa == 0);		DBUG_ON(ch->remote_msgqueue_pa == 0);

	@@ -719,9 +703,8 @@ xpc_process_disconnect(struct xpc_channel ch, unsigned long irq_flags)

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

	if (!(ch->flags & XPC_C_DISCONNECTING)) {		if (!(ch->flags & XPC_C_DISCONNECTING))
	return;		return;
	}

	DBUG_ON(!(ch->flags & XPC_C_CLOSEREQUEST));		DBUG_ON(!(ch->flags & XPC_C_CLOSEREQUEST));

	@@ -736,27 +719,24 @@ xpc_process_disconnect(struct xpc_channel ch, unsigned long irq_flags)

	if (part->act_state == XPC_P_DEACTIVATING) {		if (part->act_state == XPC_P_DEACTIVATING) {
	/* can't proceed until the other side disengages from us */		/* can't proceed until the other side disengages from us */
	if (xpc_partition_engaged(1UL << ch->partid)) {		if (xpc_partition_engaged(1UL << ch->partid))
	return;		return;
	}

	} else {		} else {

	/* as long as the other side is up do the full protocol */		/* as long as the other side is up do the full protocol */

	if (!(ch->flags & XPC_C_RCLOSEREQUEST)) {		if (!(ch->flags & XPC_C_RCLOSEREQUEST))
	return;		return;
	}

	if (!(ch->flags & XPC_C_CLOSEREPLY)) {		if (!(ch->flags & XPC_C_CLOSEREPLY)) {
	ch->flags \|= XPC_C_CLOSEREPLY;		ch->flags \|= XPC_C_CLOSEREPLY;
	xpc_IPI_send_closereply(ch, irq_flags);		xpc_IPI_send_closereply(ch, irq_flags);
	}		}

	if (!(ch->flags & XPC_C_RCLOSEREPLY)) {		if (!(ch->flags & XPC_C_RCLOSEREPLY))
	return;		return;
	}		}
	}

	/* wake those waiting for notify completion */		/* wake those waiting for notify completion */
	if (atomic_read(&ch->n_to_notify) > 0) {		if (atomic_read(&ch->n_to_notify) > 0) {
	@@ -817,7 +797,8 @@ xpc_process_openclose_IPI(struct xpc_partition *part, int ch_number,

	again:		again:

	if ((ch->flags & XPC_C_DISCONNECTED) && (ch->flags & XPC_C_WDISCONNECT)) {		if ((ch->flags & XPC_C_DISCONNECTED) &&
			(ch->flags & XPC_C_WDISCONNECT)) {
	/*		/*
	* Delay processing IPI flags until thread waiting disconnect		* Delay processing IPI flags until thread waiting disconnect
	* has had a chance to see that the channel is disconnected.		* has had a chance to see that the channel is disconnected.
	@@ -890,11 +871,10 @@ xpc_process_openclose_IPI(struct xpc_partition *part, int ch_number,

	if (!(ch->flags & XPC_C_DISCONNECTING)) {		if (!(ch->flags & XPC_C_DISCONNECTING)) {
	reason = args->reason;		reason = args->reason;
	if (reason <= xpcSuccess \|\| reason > xpcUnknownReason) {		if (reason <= xpcSuccess \|\| reason > xpcUnknownReason)
	reason = xpcUnknownReason;		reason = xpcUnknownReason;
	} else if (reason == xpcUnregistering) {		else if (reason == xpcUnregistering)
	reason = xpcOtherUnregistering;		reason = xpcOtherUnregistering;
	}

	XPC_DISCONNECT_CHANNEL(ch, reason, &irq_flags);		XPC_DISCONNECT_CHANNEL(ch, reason, &irq_flags);

	@@ -1068,9 +1048,8 @@ xpc_connect_channel(struct xpc_channel *ch)
	unsigned long irq_flags;		unsigned long irq_flags;
	struct xpc_registration *registration = &xpc_registrations[ch->number];		struct xpc_registration *registration = &xpc_registrations[ch->number];

	if (mutex_trylock(&registration->mutex) == 0) {		if (mutex_trylock(&registration->mutex) == 0)
	return xpcRetry;		return xpcRetry;
	}

	if (!XPC_CHANNEL_REGISTERED(ch->number)) {		if (!XPC_CHANNEL_REGISTERED(ch->number)) {
	mutex_unlock(&registration->mutex);		mutex_unlock(&registration->mutex);
	@@ -1159,7 +1138,7 @@ xpc_clear_local_msgqueue_flags(struct xpc_channel *ch)
	(get % ch->local_nentries) *		(get % ch->local_nentries) *
	ch->msg_size);		ch->msg_size);
	msg->flags = 0;		msg->flags = 0;
	} while (++get < (volatile s64)ch->remote_GP.get);		} while (++get < ch->remote_GP.get);
	}		}

	/*		/*
	@@ -1177,7 +1156,7 @@ xpc_clear_remote_msgqueue_flags(struct xpc_channel *ch)
	(put % ch->remote_nentries) *		(put % ch->remote_nentries) *
	ch->msg_size);		ch->msg_size);
	msg->flags = 0;		msg->flags = 0;
	} while (++put < (volatile s64)ch->remote_GP.put);		} while (++put < ch->remote_GP.put);
	}		}

	static void		static void
	@@ -1244,10 +1223,9 @@ xpc_process_msg_IPI(struct xpc_partition *part, int ch_number)
	* If anyone was waiting for message queue entries to become		* If anyone was waiting for message queue entries to become
	* available, wake them up.		* available, wake them up.
	*/		*/
	if (atomic_read(&ch->n_on_msg_allocate_wq) > 0) {		if (atomic_read(&ch->n_on_msg_allocate_wq) > 0)
	wake_up(&ch->msg_allocate_wq);		wake_up(&ch->msg_allocate_wq);
	}		}
	}

	/*		/*
	* Now check for newly sent messages by the other side. (The remote		* Now check for newly sent messages by the other side. (The remote
	@@ -1273,11 +1251,10 @@ xpc_process_msg_IPI(struct xpc_partition *part, int ch_number)
	"delivered=%d, partid=%d, channel=%d\n",		"delivered=%d, partid=%d, channel=%d\n",
	nmsgs_sent, ch->partid, ch->number);		nmsgs_sent, ch->partid, ch->number);

	if (ch->flags & XPC_C_CONNECTEDCALLOUT_MADE) {		if (ch->flags & XPC_C_CONNECTEDCALLOUT_MADE)
	xpc_activate_kthreads(ch, nmsgs_sent);		xpc_activate_kthreads(ch, nmsgs_sent);
	}		}
	}		}
	}

	xpc_msgqueue_deref(ch);		xpc_msgqueue_deref(ch);
	}		}
	@@ -1310,9 +1287,8 @@ xpc_process_channel_activity(struct xpc_partition *part)

	IPI_flags = XPC_GET_IPI_FLAGS(IPI_amo, ch_number);		IPI_flags = XPC_GET_IPI_FLAGS(IPI_amo, ch_number);

	if (XPC_ANY_OPENCLOSE_IPI_FLAGS_SET(IPI_flags)) {		if (XPC_ANY_OPENCLOSE_IPI_FLAGS_SET(IPI_flags))
	xpc_process_openclose_IPI(part, ch_number, IPI_flags);		xpc_process_openclose_IPI(part, ch_number, IPI_flags);
	}

	ch_flags = ch->flags; /* need an atomic snapshot of flags */		ch_flags = ch->flags; /* need an atomic snapshot of flags */

	@@ -1323,9 +1299,8 @@ xpc_process_channel_activity(struct xpc_partition *part)
	continue;		continue;
	}		}

	if (part->act_state == XPC_P_DEACTIVATING) {		if (part->act_state == XPC_P_DEACTIVATING)
	continue;		continue;
	}

	if (!(ch_flags & XPC_C_CONNECTED)) {		if (!(ch_flags & XPC_C_CONNECTED)) {
	if (!(ch_flags & XPC_C_OPENREQUEST)) {		if (!(ch_flags & XPC_C_OPENREQUEST)) {
	@@ -1345,11 +1320,10 @@ xpc_process_channel_activity(struct xpc_partition *part)
	* from the other partition.		* from the other partition.
	*/		*/

	if (XPC_ANY_MSG_IPI_FLAGS_SET(IPI_flags)) {		if (XPC_ANY_MSG_IPI_FLAGS_SET(IPI_flags))
	xpc_process_msg_IPI(part, ch_number);		xpc_process_msg_IPI(part, ch_number);
	}		}
	}		}
	}

	/*		/*
	* XPC's heartbeat code calls this function to inform XPC that a partition is		* XPC's heartbeat code calls this function to inform XPC that a partition is
	@@ -1560,9 +1534,9 @@ xpc_disconnect_channel(const int line, struct xpc_channel *ch,

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

	if (ch->flags & (XPC_C_DISCONNECTING \| XPC_C_DISCONNECTED)) {		if (ch->flags & (XPC_C_DISCONNECTING \| XPC_C_DISCONNECTED))
	return;		return;
	}
	DBUG_ON(!(ch->flags & (XPC_C_CONNECTING \| XPC_C_CONNECTED)));		DBUG_ON(!(ch->flags & (XPC_C_CONNECTING \| XPC_C_CONNECTED)));

	dev_dbg(xpc_chan, "reason=%d, line=%d, partid=%d, channel=%d\n",		dev_dbg(xpc_chan, "reason=%d, line=%d, partid=%d, channel=%d\n",
	@@ -1578,9 +1552,8 @@ xpc_disconnect_channel(const int line, struct xpc_channel *ch,

	xpc_IPI_send_closerequest(ch, irq_flags);		xpc_IPI_send_closerequest(ch, irq_flags);

	if (channel_was_connected) {		if (channel_was_connected)
	ch->flags \|= XPC_C_WASCONNECTED;		ch->flags \|= XPC_C_WASCONNECTED;
	}

	spin_unlock_irqrestore(&ch->lock, *irq_flags);		spin_unlock_irqrestore(&ch->lock, *irq_flags);

	@@ -1595,9 +1568,8 @@ xpc_disconnect_channel(const int line, struct xpc_channel *ch,
	}		}

	/* wake those waiting to allocate an entry from the local msg queue */		/* wake those waiting to allocate an entry from the local msg queue */
	if (atomic_read(&ch->n_on_msg_allocate_wq) > 0) {		if (atomic_read(&ch->n_on_msg_allocate_wq) > 0)
	wake_up(&ch->msg_allocate_wq);		wake_up(&ch->msg_allocate_wq);
	}

	spin_lock_irqsave(&ch->lock, *irq_flags);		spin_lock_irqsave(&ch->lock, *irq_flags);
	}		}
	@@ -1632,7 +1604,7 @@ xpc_allocate_msg_wait(struct xpc_channel *ch)
	enum xpc_retval ret;		enum xpc_retval ret;

	if (ch->flags & XPC_C_DISCONNECTING) {		if (ch->flags & XPC_C_DISCONNECTING) {
	DBUG_ON(ch->reason == xpcInterrupted); // >>> Is this true?		DBUG_ON(ch->reason == xpcInterrupted);
	return ch->reason;		return ch->reason;
	}		}

	@@ -1642,7 +1614,7 @@ xpc_allocate_msg_wait(struct xpc_channel *ch)

	if (ch->flags & XPC_C_DISCONNECTING) {		if (ch->flags & XPC_C_DISCONNECTING) {
	ret = ch->reason;		ret = ch->reason;
	DBUG_ON(ch->reason == xpcInterrupted); // >>> Is this true?		DBUG_ON(ch->reason == xpcInterrupted);
	} else if (ret == 0) {		} else if (ret == 0) {
	ret = xpcTimeout;		ret = xpcTimeout;
	} else {		} else {
	@@ -1685,9 +1657,9 @@ xpc_allocate_msg(struct xpc_channel *ch, u32 flags,

	while (1) {		while (1) {

	put = (volatile s64)ch->w_local_GP.put;		put = ch->w_local_GP.put;
	if (put - (volatile s64)ch->w_remote_GP.get <		rmb(); /* guarantee that .put loads before .get */
	ch->local_nentries) {		if (put - ch->w_remote_GP.get < ch->local_nentries) {

	/* There are available message entries. We need to try		/* There are available message entries. We need to try
	* to secure one for ourselves. We'll do this by trying		* to secure one for ourselves. We'll do this by trying
	@@ -1711,9 +1683,8 @@ xpc_allocate_msg(struct xpc_channel *ch, u32 flags,
	* that will cause the IPI handler to fetch the latest		* that will cause the IPI handler to fetch the latest
	* GP values as if an IPI was sent by the other side.		* GP values as if an IPI was sent by the other side.
	*/		*/
	if (ret == xpcTimeout) {		if (ret == xpcTimeout)
	xpc_IPI_send_local_msgrequest(ch);		xpc_IPI_send_local_msgrequest(ch);
	}

	if (flags & XPC_NOWAIT) {		if (flags & XPC_NOWAIT) {
	xpc_msgqueue_deref(ch);		xpc_msgqueue_deref(ch);
	@@ -1772,10 +1743,9 @@ xpc_initiate_allocate(partid_t partid, int ch_number, u32 flags, void **payload)
	ret = xpc_allocate_msg(&part->channels[ch_number], flags, &msg);		ret = xpc_allocate_msg(&part->channels[ch_number], flags, &msg);
	xpc_part_deref(part);		xpc_part_deref(part);

	if (msg != NULL) {		if (msg != NULL)
	*payload = &msg->payload;		*payload = &msg->payload;
	}		}
	}

	return ret;		return ret;
	}		}
	@@ -1795,17 +1765,15 @@ xpc_send_msgs(struct xpc_channel *ch, s64 initial_put)
	while (1) {		while (1) {

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

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

	if (!(msg->flags & XPC_M_READY)) {		if (!(msg->flags & XPC_M_READY))
	break;		break;
	}

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

	@@ -1837,10 +1805,9 @@ xpc_send_msgs(struct xpc_channel *ch, s64 initial_put)
	initial_put = put;		initial_put = put;
	}		}

	if (send_IPI) {		if (send_IPI)
	xpc_IPI_send_msgrequest(ch);		xpc_IPI_send_msgrequest(ch);
	}		}
	}

	/*		/*
	* Common code that does the actual sending of the message by advancing the		* Common code that does the actual sending of the message by advancing the
	@@ -1880,7 +1847,7 @@ xpc_send_msg(struct xpc_channel ch, struct xpc_msg msg, u8 notify_type,
	notify->key = key;		notify->key = key;
	notify->type = notify_type;		notify->type = notify_type;

	// >>> is a mb() needed here?		/* >>> is a mb() needed here? */

	if (ch->flags & XPC_C_DISCONNECTING) {		if (ch->flags & XPC_C_DISCONNECTING) {
	/*		/*
	@@ -1913,9 +1880,8 @@ xpc_send_msg(struct xpc_channel ch, struct xpc_msg msg, u8 notify_type,
	/* see if the message is next in line to be sent, if so send it */		/* see if the message is next in line to be sent, if so send it */

	put = ch->local_GP->put;		put = ch->local_GP->put;
	if (put == msg_number) {		if (put == msg_number)
	xpc_send_msgs(ch, put);		xpc_send_msgs(ch, put);
	}

	/* drop the reference grabbed in xpc_allocate_msg() */		/* drop the reference grabbed in xpc_allocate_msg() */
	xpc_msgqueue_deref(ch);		xpc_msgqueue_deref(ch);
	@@ -2032,10 +1998,8 @@ xpc_pull_remote_msg(struct xpc_channel *ch, s64 get)

	msg_index = ch->next_msg_to_pull % ch->remote_nentries;		msg_index = ch->next_msg_to_pull % ch->remote_nentries;

	DBUG_ON(ch->next_msg_to_pull >=		DBUG_ON(ch->next_msg_to_pull >= ch->w_remote_GP.put);
	(volatile s64)ch->w_remote_GP.put);		nmsgs = ch->w_remote_GP.put - ch->next_msg_to_pull;
	nmsgs = (volatile s64)ch->w_remote_GP.put -
	ch->next_msg_to_pull;
	if (msg_index + nmsgs > ch->remote_nentries) {		if (msg_index + nmsgs > ch->remote_nentries) {
	/* ignore the ones that wrap the msg queue for now */		/* ignore the ones that wrap the msg queue for now */
	nmsgs = ch->remote_nentries - msg_index;		nmsgs = ch->remote_nentries - msg_index;
	@@ -2046,9 +2010,9 @@ xpc_pull_remote_msg(struct xpc_channel *ch, s64 get)
	remote_msg = (struct xpc_msg *)(ch->remote_msgqueue_pa +		remote_msg = (struct xpc_msg *)(ch->remote_msgqueue_pa +
	msg_offset);		msg_offset);

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

	dev_dbg(xpc_chan, "failed to pull %d msgs starting with"		dev_dbg(xpc_chan, "failed to pull %d msgs starting with"
	" msg %ld from partition %d, channel=%d, "		" msg %ld from partition %d, channel=%d, "
	@@ -2061,8 +2025,6 @@ xpc_pull_remote_msg(struct xpc_channel *ch, s64 get)
	return NULL;		return NULL;
	}		}

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

	ch->next_msg_to_pull += nmsgs;		ch->next_msg_to_pull += nmsgs;
	}		}

	@@ -2085,14 +2047,13 @@ xpc_get_deliverable_msg(struct xpc_channel *ch)
	s64 get;		s64 get;

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

	get = (volatile s64)ch->w_local_GP.get;		get = ch->w_local_GP.get;
	if (get == (volatile s64)ch->w_remote_GP.put) {		rmb(); /* guarantee that .get loads before .put */
			if (get == ch->w_remote_GP.put)
	break;		break;
	}

	/* There are messages waiting to be pulled and delivered.		/* There are messages waiting to be pulled and delivered.
	* We need to try to secure one for ourselves. We'll do this		* We need to try to secure one for ourselves. We'll do this
	@@ -2132,7 +2093,8 @@ xpc_deliver_msg(struct xpc_channel *ch)
	{		{
	struct xpc_msg *msg;		struct xpc_msg *msg;

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

	/*		/*
	* This ref is taken to protect the payload itself from being		* This ref is taken to protect the payload itself from being
	@@ -2178,17 +2140,15 @@ xpc_acknowledge_msgs(struct xpc_channel *ch, s64 initial_get, u8 msg_flags)
	while (1) {		while (1) {

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

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

	if (!(msg->flags & XPC_M_DONE)) {		if (!(msg->flags & XPC_M_DONE))
	break;		break;
	}

	msg_flags \|= msg->flags;		msg_flags \|= msg->flags;
	get++;		get++;
	@@ -2202,7 +2162,7 @@ xpc_acknowledge_msgs(struct xpc_channel *ch, s64 initial_get, u8 msg_flags)
	if (cmpxchg_rel(&ch->local_GP->get, initial_get, get) !=		if (cmpxchg_rel(&ch->local_GP->get, initial_get, get) !=
	initial_get) {		initial_get) {
	/* someone else beat us to it */		/* someone else beat us to it */
	DBUG_ON((volatile s64)ch->local_GP->get <= initial_get);		DBUG_ON(ch->local_GP->get <= initial_get);
	break;		break;
	}		}

	@@ -2221,10 +2181,9 @@ xpc_acknowledge_msgs(struct xpc_channel *ch, s64 initial_get, u8 msg_flags)
	initial_get = get;		initial_get = get;
	}		}

	if (send_IPI) {		if (send_IPI)
	xpc_IPI_send_msgrequest(ch);		xpc_IPI_send_msgrequest(ch);
	}		}
	}

	/*		/*
	* Acknowledge receipt of a delivered message.		* Acknowledge receipt of a delivered message.
	@@ -2276,9 +2235,8 @@ xpc_initiate_received(partid_t partid, int ch_number, void *payload)
	* been delivered.		* been delivered.
	*/		*/
	get = ch->local_GP->get;		get = ch->local_GP->get;
	if (get == msg_number) {		if (get == msg_number)
	xpc_acknowledge_msgs(ch, get, msg->flags);		xpc_acknowledge_msgs(ch, get, msg->flags);
	}

	/* the call to xpc_msgqueue_ref() was done by xpc_deliver_msg() */		/* the call to xpc_msgqueue_ref() was done by xpc_deliver_msg() */
	xpc_msgqueue_deref(ch);		xpc_msgqueue_deref(ch);

drivers/misc/sgi-xp/xpc_main.c

+56 −111

File changed.

Preview size limit exceeded, changes collapsed.