Merge branch 'locking-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

variable a, then the compiler is within its rights transforming this to

the following::

	tmp = a;

	if (a > 0)

		for (;;)

			do_something();

If you don't want the compiler to do this (and you probably don't), then

you should use something like the following::

	while (READ_ONCE(a) < 0)

	while (READ_ONCE(a) > 0)

		do_something();

Alternatively, you could place a barrier() call in the loop.

indicates whether the changed bit was set _BEFORE_ the atomic bit

operation.

WARNING! It is incredibly important that the value be a boolean,

ie. "0" or "1".  Do not try to be fancy and save a few instructions by

declaring the above to return "long" and just returning something like

"old_val & mask" because that will not work.

.. warning::

        It is incredibly important that the value be a boolean, ie. "0" or "1".

        Do not try to be fancy and save a few instructions by declaring the

        above to return "long" and just returning something like "old_val &

        mask" because that will not work.

For one thing, this return value gets truncated to int in many code

paths using these interfaces, so on 64-bit if the bit is set in the

		/* assign ownership */

		desc->status = DEVICE_OWN;

		/* force memory to sync before notifying device via MMIO */

		wmb();

		/* notify device of new descriptors */

		writel(DESC_NOTIFY, doorbell);

	}

     The dma_rmb() allows us guarantee the device has released ownership

     before we read the data from the descriptor, and the dma_wmb() allows

     us to guarantee the data is written to the descriptor before the device

     can see it now has ownership.  The wmb() is needed to guarantee that the

     cache coherent memory writes have completed before attempting a write to

     the cache incoherent MMIO region.

     See Documentation/DMA-API.txt for more information on consistent memory.

     can see it now has ownership.  Note that, when using writel(), a prior

     wmb() is not needed to guarantee that the cache coherent memory writes

     have completed before writing to the MMIO region.  The cheaper

     writel_relaxed() does not provide this guarantee and must not be used

     here.

     See the subsection "Kernel I/O barrier effects" for more information on

     relaxed I/O accessors and the Documentation/DMA-API.txt file for more

     information on consistent memory.

MMIO WRITE BARRIER

부분도 있고, 의도하진 않았지만 사람에 의해 쓰였다보니 불완전한 부분도 있습니다.

이 문서는 리눅스에서 제공하는 다양한 메모리 배리어들을 사용하기 위한

안내서입니다만, 뭔가 이상하다 싶으면 (그런게 많을 겁니다) 질문을 부탁드립니다.

일부 이상한 점들은 공식적인 메모리 일관성 모델과 tools/memory-model/ 에 있는

관련 문서를 참고해서 해결될 수 있을 겁니다.  그러나, 이 메모리 모델조차도 그

관리자들의 의견의 집합으로 봐야지, 절대 옳은 예언자로 신봉해선 안될 겁니다.

다시 말하지만, 이 문서는 리눅스가 하드웨어에 기대하는 사항에 대한 명세서가

아닙니다.

     - 메모리 배리어의 종류.

     - 메모리 배리어에 대해 가정해선 안될 것.

     - 데이터 의존성 배리어.

     - 데이터 의존성 배리어 (역사적).

     - 컨트롤 의존성.

     - SMP 배리어 짝맞추기.

     - 메모리 배리어 시퀀스의 예.

 (*) 어떤 CPU 든, 의존성이 존재하는 메모리 액세스들은 해당 CPU 자신에게

     있어서는 순서대로 메모리 시스템에 수행 요청됩니다. 즉, 다음에 대해서:

	Q = READ_ONCE(P); smp_read_barrier_depends(); D = READ_ONCE(*Q);

	Q = READ_ONCE(P); D = READ_ONCE(*Q);

     CPU 는 다음과 같은 메모리 오퍼레이션 시퀀스를 수행 요청합니다:

	Q = LOAD P, D = LOAD *Q

     그리고 그 시퀀스 내에서의 순서는 항상 지켜집니다.  대부분의 시스템에서

     smp_read_barrier_depends() 는 아무일도 안하지만 DEC Alpha 에서는

     명시적으로 사용되어야 합니다.  보통의 경우에는 smp_read_barrier_depends()

     를 직접 사용하는 대신 rcu_dereference() 같은 것들을 사용해야 함을

     알아두세요.

     그리고 그 시퀀스 내에서의 순서는 항상 지켜집니다.  하지만, DEC Alpha 에서

     READ_ONCE() 는 메모리 배리어 명령도 내게 되어 있어서, DEC Alpha CPU 는

     다음과 같은 메모리 오퍼레이션들을 내놓게 됩니다:

	Q = LOAD P, MEMORY_BARRIER, D = LOAD *Q, MEMORY_BARRIER

     DEC Alpha 에서 수행되든 아니든, READ_ONCE() 는 컴파일러로부터의 악영향

     또한 제거합니다.

 (*) 특정 CPU 내에서 겹치는 영역의 메모리에 행해지는 로드와 스토어 들은 해당

     CPU 안에서는 순서가 바뀌지 않은 것으로 보여집니다.  즉, 다음에 대해서:

     데이터 의존성 배리어는 읽기 배리어의 보다 완화된 형태입니다.  두개의 로드

     오퍼레이션이 있고 두번째 것이 첫번째 것의 결과에 의존하고 있을 때(예:

     두번째 로드가 참조할 주소를 첫번째 로드가 읽는 경우), 두번째 로드가 읽어올

     데이터는 첫번째 로드에 의해 그 주소가 얻어지기 전에 업데이트 되어 있음을

     보장하기 위해서 데이터 의존성 배리어가 필요할 수 있습니다.

     데이터는 첫번째 로드에 의해 그 주소가 얻어진 뒤에 업데이트 됨을 보장하기

     위해서 데이터 의존성 배리어가 필요할 수 있습니다.

     데이터 의존성 배리어는 상호 의존적인 로드 오퍼레이션들 사이의 부분적 순서

     세우기입니다; 스토어 오퍼레이션들이나 독립적인 로드들, 또는 중복되는

	    Documentation/DMA-API.txt

데이터 의존성 배리어

--------------------

데이터 의존성 배리어 (역사적)

-----------------------------

리눅스 커널 v4.15 기준으로, smp_read_barrier_depends() 가 READ_ONCE() 에

추가되었는데, 이는 이 섹션에 주의를 기울여야 하는 사람들은 DEC Alpha 아키텍쳐

전용 코드를 만드는 사람들과 READ_ONCE() 자체를 만드는 사람들 뿐임을 의미합니다.

그런 분들을 위해, 그리고 역사에 관심 있는 분들을 위해, 여기 데이터 의존성

배리어에 대한 이야기를 적습니다.

데이터 의존성 배리어의 사용에 있어 지켜야 하는 사항들은 약간 미묘하고, 데이터

의존성 배리어가 사용되어야 하는 상황도 항상 명백하지는 않습니다.  설명을 위해

	범용		mb()			smp_mb()

	쓰기		wmb()			smp_wmb()

	읽기		rmb()			smp_rmb()

	데이터 의존성	read_barrier_depends()	smp_read_barrier_depends()

	데이터 의존성				READ_ONCE()

데이터 의존성 배리어를 제외한 모든 메모리 배리어는 컴파일러 배리어를

여기에 개입하기 위해선, 데이터 의존성 배리어나 읽기 배리어를 로드 오퍼레이션들

사이에 넣어야 합니다.  이렇게 함으로써 캐시가 다음 요청을 처리하기 전에 일관성

큐를 처리하도록 강제하게 됩니다.

사이에 넣어야 합니다 (v4.15 부터는 READ_ONCE() 매크로에 의해 무조건적으로

그렇게 됩니다).  이렇게 함으로써 캐시가 다음 요청을 처리하기 전에 일관성 큐를

처리하도록 강제하게 됩니다.

	CPU 1		CPU 2		COMMENT

	===============	===============	=======================================

다른 CPU 들도 분할된 캐시를 가지고 있을 수 있지만, 그런 CPU 들은 평범한 메모리

액세스를 위해서도 이 분할된 캐시들 사이의 조정을 해야만 합니다.  Alpha 는 가장

약한 메모리 순서 시맨틱 (semantic) 을 선택함으로써 메모리 배리어가 명시적으로

사용되지 않았을 때에는 그런 조정이 필요하지 않게 했습니다.

사용되지 않았을 때에는 그런 조정이 필요하지 않게 했으며, 이는 Alpha 가 당시에

더 높은 CPU 클락 속도를 가질 수 있게 했습니다.  하지만, (다시 말하건대, v4.15

이후부터는) Alpha 아키텍쳐 전용 코드와 READ_ONCE() 매크로 내부에서를 제외하고는

smp_read_barrier_depends() 가 사용되지 않아야 함을 알아두시기 바랍니다.

캐시 일관성 VS DMA

메모리 일관성 시스템과 함께 두개의 캐시를 동기화 시켜서, 포인터 변경과 새로운

데이터의 발견을 올바른 순서로 일어나게 하기 때문입니다.

리눅스 커널의 메모리 배리어 모델은 Alpha 에 기초해서 정의되었습니다.

리눅스 커널의 메모리 배리어 모델은 Alpha 에 기초해서 정의되었습니다만, v4.15

부터는 리눅스 커널이 READ_ONCE() 내에 smp_read_barrier_depends() 를 추가해서

Alpha 의 메모리 모델로의 영향력이 크게 줄어들긴 했습니다.

위의 "캐시 일관성" 서브섹션을 참고하세요.

LINUX KERNEL MEMORY CONSISTENCY MODEL (LKMM)

M:	Alan Stern <stern@rowland.harvard.edu>

M:	Andrea Parri <parri.andrea@gmail.com>

M:	Andrea Parri <andrea.parri@amarulasolutions.com>

M:	Will Deacon <will.deacon@arm.com>

M:	Peter Zijlstra <peterz@infradead.org>

M:	Boqun Feng <boqun.feng@gmail.com>

LOCKING PRIMITIVES

M:	Peter Zijlstra <peterz@infradead.org>

M:	Ingo Molnar <mingo@redhat.com>

M:	Will Deacon <will.deacon@arm.com>

L:	linux-kernel@vger.kernel.org

T:	git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git locking/core

S:	Maintained

static inline int arch_spin_is_locked(arch_spinlock_t *lock)

{

	/*

	 * Ensure prior spin_lock operations to other locks have completed

	 * on this CPU before we test whether "lock" is locked.

	 */

	smp_mb(); /* ^^^ */

	return !arch_spin_value_unlocked(READ_ONCE(*lock));

}