Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
awilliam
GitHub Repository: awilliam/linux-vfio
 Path: blob/master/arch/powerpc/lib/locks.c
10817 views
1
/*

2
 * Spin and read/write lock operations.

3
 *

4
 * Copyright (C) 2001-2004 Paul Mackerras <[email protected]>, IBM

5
 * Copyright (C) 2001 Anton Blanchard <[email protected]>, IBM

6
 * Copyright (C) 2002 Dave Engebretsen <[email protected]>, IBM

7
 *   Rework to support virtual processors

8
 *

9
 * This program is free software; you can redistribute it and/or

10
 * modify it under the terms of the GNU General Public License

11
 * as published by the Free Software Foundation; either version

12
 * 2 of the License, or (at your option) any later version.

13
 */

14


15
#include <linux/kernel.h>

16
#include <linux/spinlock.h>

17
#include <linux/module.h>

18
#include <linux/stringify.h>

19
#include <linux/smp.h>

20


21
/* waiting for a spinlock... */

22
#if defined(CONFIG_PPC_SPLPAR) || defined(CONFIG_PPC_ISERIES)

23
#include <asm/hvcall.h>

24
#include <asm/iseries/hv_call.h>

25
#include <asm/smp.h>

26
#include <asm/firmware.h>

27


28
void __spin_yield(arch_spinlock_t *lock)

29
{

30
	unsigned int lock_value, holder_cpu, yield_count;

31


32
	lock_value = lock->slock;

33
	if (lock_value == 0)

34
		return;

35
	holder_cpu = lock_value & 0xffff;

36
	BUG_ON(holder_cpu >= NR_CPUS);

37
	yield_count = lppaca_of(holder_cpu).yield_count;

38
	if ((yield_count & 1) == 0)

39
		return;		/* virtual cpu is currently running */

40
	rmb();

41
	if (lock->slock != lock_value)

42
		return;		/* something has changed */

43
	if (firmware_has_feature(FW_FEATURE_ISERIES))

44
		HvCall2(HvCallBaseYieldProcessor, HvCall_YieldToProc,

45
			((u64)holder_cpu << 32) | yield_count);

46
#ifdef CONFIG_PPC_SPLPAR

47
	else

48
		plpar_hcall_norets(H_CONFER,

49
			get_hard_smp_processor_id(holder_cpu), yield_count);

50
#endif

51
}

52


53
/*

54
 * Waiting for a read lock or a write lock on a rwlock...

55
 * This turns out to be the same for read and write locks, since

56
 * we only know the holder if it is write-locked.

57
 */

58
void __rw_yield(arch_rwlock_t *rw)

59
{

60
	int lock_value;

61
	unsigned int holder_cpu, yield_count;

62


63
	lock_value = rw->lock;

64
	if (lock_value >= 0)

65
		return;		/* no write lock at present */

66
	holder_cpu = lock_value & 0xffff;

67
	BUG_ON(holder_cpu >= NR_CPUS);

68
	yield_count = lppaca_of(holder_cpu).yield_count;

69
	if ((yield_count & 1) == 0)

70
		return;		/* virtual cpu is currently running */

71
	rmb();

72
	if (rw->lock != lock_value)

73
		return;		/* something has changed */

74
	if (firmware_has_feature(FW_FEATURE_ISERIES))

75
		HvCall2(HvCallBaseYieldProcessor, HvCall_YieldToProc,

76
			((u64)holder_cpu << 32) | yield_count);

77
#ifdef CONFIG_PPC_SPLPAR

78
	else

79
		plpar_hcall_norets(H_CONFER,

80
			get_hard_smp_processor_id(holder_cpu), yield_count);

81
#endif

82
}

83
#endif

84


85
void arch_spin_unlock_wait(arch_spinlock_t *lock)

86
{

87
	while (lock->slock) {

88
		HMT_low();

89
		if (SHARED_PROCESSOR)

90
			__spin_yield(lock);

91
	}

92
	HMT_medium();

93
}

94


95
EXPORT_SYMBOL(arch_spin_unlock_wait);

96


97