Attachment #369742 for bug #477270

View | Details | Raw Unified | Return to bug 477270
Collapse All | Expand All




   preempt_disable();

   /*
    * Call all other CPUs, but do not wait so we can enter the callback
    * on this CPU too.
    */

   compat_smp_call_function(LinuxDriverSyncCallHook, &args, 0);

   /*
    * smp_call_function doesn't return until all cpus have been
    * interrupted.  It's safe to disable interrupts now that all other
    * cpus are in their IPI handlers.




      if (targetHostCpu != INVALID_PCPU) {
         ASSERT(targetHostCpu < MAX_PCPUS);

#if defined(VMMON_USE_CALL_FUNC)
         /* older kernels IPI broadcast; use async when possible */
         (void) compat_smp_call_function(LinuxDriverIPIHandler,
                                         NULL, VMMON_CALL_FUNC_SYNC);

	 mode = IPI_BROADCAST;
	 break;
#else
         /* Newer kernels have (async) IPI targetting */
         arch_send_call_function_single_ipi(targetHostCpu);
	 mode = IPI_UNICAST;
         if (!all) {
	    break;
         }
#endif
      }
      ipiTargets = VCPUSet_Remove(ipiTargets, v);
   }

{
   preempt_disable();
   (*func)(data);
   // (void)compat_smp_call_function(*func, data, 1);
   preempt_enable();
}





#define INCLUDE_ALLOW_VMCORE
#include "includeCheck.h"


/*
 * Hide all kernel compatibility stuff in these macros and functions.
 */

#ifdef VMW_HAVE_SMP_CALL_3ARG
#define compat_smp_call_function(fn, info, wait) smp_call_function(fn, info, wait)
#else
#define compat_smp_call_function(fn, info, wait) smp_call_function(fn, info, 1, wait)
#endif

/*
 * Although this is not really related to kernel-compatibility, I put this
 * helper macro here for now for a lack of better place --hpreg

Return to bug 477270

Lines 1245-1257 Link Here

(-)work/vmmon-only/linux/driver.c (-7 lines)
1245	preempt_disable();	1245	preempt_disable();
1246		1246
1247	/*	1247	/*
1248	* Call all other CPUs, but do not wait so we can enter the callback
1249	* on this CPU too.
1250	*/
1251
1252	compat_smp_call_function(LinuxDriverSyncCallHook, &args, 0);
1253
1254	/*
1255	* smp_call_function doesn't return until all cpus have been	1248	* smp_call_function doesn't return until all cpus have been
1256	* interrupted. It's safe to disable interrupts now that all other	1249	* interrupted. It's safe to disable interrupts now that all other
1257	* cpus are in their IPI handlers.	1250	* cpus are in their IPI handlers.

Lines 2708-2728 Link Here

(-)work/vmmon-only/linux/hostif.c (-10 / +1 lines)
2708	if (targetHostCpu != INVALID_PCPU) {	2708	if (targetHostCpu != INVALID_PCPU) {
2709	ASSERT(targetHostCpu < MAX_PCPUS);	2709	ASSERT(targetHostCpu < MAX_PCPUS);
2710		2710
2711	#if defined(VMMON_USE_CALL_FUNC)
2712	/* older kernels IPI broadcast; use async when possible */
2713	(void) compat_smp_call_function(LinuxDriverIPIHandler,
2714	NULL, VMMON_CALL_FUNC_SYNC);
2715
2716	mode = IPI_BROADCAST;
2717	break;
2718	#else
2719	/* Newer kernels have (async) IPI targetting */	2711	/* Newer kernels have (async) IPI targetting */
2720	arch_send_call_function_single_ipi(targetHostCpu);	2712	arch_send_call_function_single_ipi(targetHostCpu);
2721	mode = IPI_UNICAST;	2713	mode = IPI_UNICAST;
2722	if (!all) {	2714	if (!all) {
2723	break;	2715	break;
2724	}	2716	}
2725	#endif
2726	}	2717	}
2727	ipiTargets = VCPUSet_Remove(ipiTargets, v);	2718	ipiTargets = VCPUSet_Remove(ipiTargets, v);
2728	}	2719	}
Lines 2848-2854 Link Here
2848	{	2839	{
2849	preempt_disable();	2840	preempt_disable();
2850	(*func)(data);	2841	(*func)(data);
2851	(void)compat_smp_call_function(*func, data, 1);	2842	// (void)compat_smp_call_function(*func, data, 1);
2852	preempt_enable();	2843	preempt_enable();
2853	}	2844	}
2854		2845

Lines 23-39 Link Here

(-)work/vmmon-only/linux/vmmonInt.h (-11 lines)
23	#define INCLUDE_ALLOW_VMCORE	23	#define INCLUDE_ALLOW_VMCORE
24	#include "includeCheck.h"	24	#include "includeCheck.h"
25		25
26
27	/*
28	* Hide all kernel compatibility stuff in these macros and functions.
29	*/
30
31	#ifdef VMW_HAVE_SMP_CALL_3ARG
32	#define compat_smp_call_function(fn, info, wait) smp_call_function(fn, info, wait)
33	#else
34	#define compat_smp_call_function(fn, info, wait) smp_call_function(fn, info, 1, wait)
35	#endif
36
37	/*	26	/*
38	* Although this is not really related to kernel-compatibility, I put this	27	* Although this is not really related to kernel-compatibility, I put this
39	* helper macro here for now for a lack of better place --hpreg	28	* helper macro here for now for a lack of better place --hpreg