- embedded linux conference
	http://events.linuxfoundation.org/events/archive/2016/embedded-linux-conference
- The dynamic debugging interface
	https://lwn.net/Articles/434833/
- Documentation/dynamic-debug-howto.txt
	https://lwn.net/Articles/434856/
- dynamic debug
	https://lwn.net/Articles/286191/

- head.S부터 디버깅 하려면?
	(gdb) file vmlinux
	(gdb) target remote :1234
	(gdb) load vmlinux
	(gdb) b *0x80008000
	add-symbol-file arch/arm/boot/compressed/vmlinux <- 필요한가?

- 부팅시 어디부터 실행되나?
	vmlinux uImage zImage …

- atags / devicetree
	왜 devicetree인가?
- coprocessor 명령어는 왜 필요한가?

[aarch64 관련]
- aarch64와 arm64 용어의 차이?
  arm 공식 매뉴얼에서는 뭐라고 표현하는가?
  커널에서는 어떤 표기를 사용하나?
- arm64는 왜 mach, plat 디렉토리가 필요하지 않게 되었나?
- arm64의 FVP, RTSM, Foundation Model은 무엇인가? qemu처럼 분석시 사용할 수 있나?

GDB client using gdbremote protocol

Advantages
+ Qemu is open source and has gdbremote stub
+ No “real” hardware required
+ Good for testing generic kernel code, on many architectures
+ Good environment for developing GDB linux awareness extensions
Disadvantages
- If your bug is SoC or board related it is unlikely to be useful


toolschain download
	http://www.linaro.org/downloads/

	wget … / tar -xJf …
	sudo mkdir -p /opt/crosstools
	sudo mv gcc-linaro-5.3-2016.02-x86_64_arm-linux-gnueabihf /opt/crosstools
	export PATH=$PATH:/opt/crosstools/…/bin
	export CROSS_COMPILE=arm-linux-gnueabihf-

1. make ARCH=arm vexpress_defconfig
2. make ARCh=arm xconfig
3. make ARCH=arm zImage -j8 -sw V=1 2>&1 > build.log
4. make ARCH=arm vexpress-v2p-ca9.dtb

QEMU
	git clone git://git.qemu.org/qemu.git qemu.git
	cd qemu.git
	./configure --target-list=aarch64-softmmu,arm-softmmu,arm-linux-user --enable-fdt
		ERROR: DTC (libfdt) version >= 1.4.0 not present. Your options:
	         (1) Preferred: Install the DTC (libfdt) devel package
	         (2) Fetch the DTC submodule, using:
	             git submodule update --init dtc	<——— 실행
	make


[참고] http://www.bennee.com/~alex/blog/2014/05/09/running-linux-in-qemus-aarch64-system-emulation-mode/		

qemu-system-arm -kernel arch/arm/boot/zImage -dtb arch/arm/boot/dts/vexpress-v2p-ca9.dtb -m 512 -M vexpress-a9 -cpu cortex-a9 -append "console=ttyAMA0"




qemu linux build...
http://imvoid.wordpress.com/2013/05/21/building-and-booting-linux-using-qemu/
http://www.linuxforu.com/2011/06/qemu-for-embedded-systems-development-part-1/

Debugging ARM programs inside QEMU
http://balau82.wordpress.com/2010/08/17/debugging-arm-programs-inside-qemu/

qemu build
(enable-sdl을 위해 libsdl 제공하는 package 설치해야 함, target-list에서 softmmu와 arm-linux-user 차이점은?)
$ ./configure --enable-sdl --disable-kvm --enable-debug --target-list="arm-softmmu arm-linux-user"
$ make -j4
$ make install



qemu-system-arm -M vexpress-a9 -dtb ./arch/arm/boot/dts/vexpress-v2p-ca9.dtb -kernel ./arch/arm/boot/zImage -append "root=/dev/mmcblk0 console=ttyAMA0" -sd ../Images/RootFS.ext3 -serial stdio -s -S

# qemu-system-arm -kernel arch/arm/boot/zImage -dtb ./rtsm_ve-cortex_a15x4.dtb -m 512 -M vexpress-a15 -serial stdio -append "console=ttyAMA0"

$ qemu-system-aarch64 -m 512 -kernel linux-system-foundation.axf -hda saucy-arm64-multiarch.img

https://balau82.wordpress.com/2012/03/31/compile-linux-kernel-3-2-for-arm-and-emulate-with-qemu/

Running Linux in QEMU’s aarch64 system emulation mode
http://www.bennee.com/~alex/blog/2014/05/09/running-linux-in-qemus-aarch64-system-emulation-mode/

aarch64 memory model에 대한 파악
https://www.kernel.org/doc/Documentation/arm64/memory.txt



- 64bit OS에서  32bit application 수행시 어떻게 aarch32로 전환되어 수행되는가?
	process reset?
	mode control로 ?
- Automatic event signaling ???
	This enables power-efficient, high-performance spinlocks.
- Larger register files
	Thirty-one 64-bit general-purpose registers increase performance and reduce stack use.
	banked까지 포함???
- Hardware-accelerated cryptography
	instruction이 제공???

2016.05.14 chapter 2까지 리딩.

hypervisor가 guest os를 


Chapter 3.Fundamentals of ARMv8
- Exception level : In ARMv8, execution occurs at one of four Exception levels.
    In AArch64, the Exception level determines the level of privilege, in a similar way to the privilege levels defined in ARMv7. 
- security states : ARMv8-A provides two security states, Secure and Non-secure. The Non-secure state is also referred to as the Normal World.
- Execution States: The ARMv8 architecture defines two Execution States, AArch64 and AArch32.

- In AArch64, the processor modes are mapped onto the Exception levels as in Figure 3-6.
  As in ARMv7 (AArch32) when an exception is taken, the processor changes to the Exception level (mode) that supports the handling of the exception.

To change between execution states at the same Exception level, you have to switch to a higher Exception level then return to the original Exception level.
	=> 같은 exception level에서 execution state를 바꾸려면 상위 EL로 올라갔다가 return 해야 한다.

There are times when you must change the execution state of your system.
This could be, for example, if you are running a 64-bit operating system, and want to run a 32-bit application at EL0. To do this, the system must change to AArch32.
64비트 os에서 32비트 elf를 실행할 때, execution state를 32비트로 전환시켜야 할텐데, 그 작업을 수행하는 커널 코드는?



2016.05.28 chapter 3까지 리딩.


chapter 4.

The selected Stack Pointer can be indicated by a suffix to the Exception level:
	t Indicates use of the SP0 Stack Pointer.
	h Indicates use of the SPx Stack Pointer.
Note
The t and h suffixes are based on the terminology of thread and handler, introduced in ARMv7-M.

When in AArch64 at an Exception level other than EL0, the processor can use either:
• A dedicated 64-bit stack pointer associated with that Exception level (SP_ELn).
• The stack pointer associated with EL0 (SP_EL0).
EL0 can only ever access SP_EL0.

EL0는 SP_EL0만 접근 가능하다.

Exception level		Options
==================================
EL0			EL0t
EL1			EL1t, EL1h	; EL1t를 만든 이유가 뭘까? EL0의 SP를 접근하는 것인데…
EL2			EL2t, EL2h
EL3			EL3t, EL3h

ERET 명령어로  exception에서 복귀해 돌아갈 때 SPSR_ELn이 PSTATE로 복사된다. 주소는 ELR_ELn에 저장된 주소부터 수행된다.

Table 8-4 shows how the CPSR is replaced by named fields within PSTATE.
	MRS X0, NZCV


* CP15 명령이 사라지고 system configuration register로 제어가능하다.
In AArch64, system configuration is controlled through system registers, and accessed using MSR and MRS instructions.
This contrasts with ARMv7-A, where such registers were typically accessed through coprocessor 15 (CP15) operations.
The name of a register tells you the lowest Exception level that it can be accessed from.
For example:
	• TTBR0_EL1 is accessible from EL1, EL2, and EL3.	// EL1 레지스터는 EL1, 2, 3에서 접근 가능.
	• TTBR0_EL2 is accessible from EL2 and EL3.


aarch64로 빌드된 커널이 CONFIG_COMPAT일 경우 aarch32와 aarch64를 모두 지원한다.
	- elf header를 보고 변경시켜 주는 것인지?
	- system call 발생시키는 instruction을 decoding 해 판단하는 것인지?



6.3.11 Synchronization primitives
	LDXR/STXR
	LDXRP/STXRP : to allow code to atomically update a location that spans two registers.
	LDAXR/STLXR

	CONFIG_ARM64_LSE_ATOMICS

13.2.1 One-way barriers



13.2 Barriers



gcc -dM -E -xc /dev/null



6.18
5.1.2 Addressing
	Alignment checking



6.25일에
6.3 볼 차례

	zero extension
	sign extension
		            00 1010
		0000 0000 0000 1010

			11 1111 0001
		1111 1111 1111 0001

	x29 : fp
	x30 : lr
	sp, 따로, pc 따로


7.2일
	8. porting A64 볼 차례

	* addressing mode
	  - offset mode
		LDR X0, [X1, X2, LSL, #3]
	  - pre-index
	    LDR X0, [X1, #8]!
	  - post-index
		LDR X0, [X1], #8
	  - pc-relative (new)
		LDR X0, <label>

	* ldar / stlr
	  - load-acquire
	  - store-release


7.9
	
	9. The ABI for ARM 64-bit Architecture
	10.2.6 The Exception Syndrome Register


7.16
	11.1까지.


7.23
	armv8의 page granual
	vipt-nonaliasing

	A53, A57 비교
	Table 2-1 Comparison of ARMv8-A processors

	WA, RA (Write alloc, Read alloc) 설정하는 곳?
		다른 곳 설명을 보면 메모리 로케이션마다…

	11.4 PoC, PoU
		PoC : Point of Coherency
		PoU : Point of Unification

	11.5 Cache maintenance
		For each of these operations, you can select which of the entries the operation should apply to: 부터…

7.30
	TLB 옵션으로 IS만 사용. 할 때가 있고 안 할 때가 있는데?

	inner shareable, outer shareable : http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.den0024a/CEGDBEJE.html
	13.3.1
	https://community.arm.com/thread/4800
	https://community.arm.com/thread/3005
	http://events.linuxfoundation.org/sites/events/files/slides/weak-to-weedy.pdf
	https://community.arm.com/thread/5400
	https://www.arm.com/files/pdf/CacheCoherencyWhitepaper_6June2011.pdf

		The division between inner and outer is implementation defined, but typically the set of inner attributes is used by caches that are integrated
		into the processor, whereas the outer attributes are exported from the processor to the external memory bus and are therefore potentially used
		by cache hardware external to the core or cluster.

	local -> none shareable, is -> inner shareable
     66 static inline void local_flush_tlb_all(void)
     67 {
     68     dsb(nshst);
     69     asm("tlbi   vmalle1");
     70     dsb(nsh);
     71     isb();
     72 }
     73
     74 static inline void flush_tlb_all(void)
     75 {
     76     dsb(ishst);
     77     asm("tlbi   vmalle1is");
     78     dsb(ish);
     79     isb();
     80 }

	12-6 페이지 볼 차례


		local_flush_tlb_all	asm("tlbi   vmalle1");
		flush_tlb_all		asm("tlbi   vmalle1is");

			=> inner가 따로 묶여 있는 경우에는 어떤 명령으로? 아니면 아예 명령을 내릴 필요가 없나?

8.6
	TLB entry마다 지정하는 size가 다를텐데, 그것은 어떻게 구분되는지?
	VA | PA | attribute   <- attribute의 size 정보? VA?

	The ARMv8-A architecture provides a feature known as contiguous block entries to efficiently use TLB space.
	Translation table block entries each contain a contiguous bit. When set,			<-  여기서 말하는 block이란?
	this bit signals to the TLB that it can cache a single entry covering translations for multiple blocks. A lookup can
	index anywhere into an address range covered by a contiguous block. 
	
	제공하는 granule???
		Page Table은 granule 4KB, 16KB, 64KB (CONFIG_ARM64_4K_PAGES,16K, 64K)
		ID_AA64MMFR0_EL1에 레지스터 TGRAN에 세팅.

	config PGTABLE_LEVELS
	    int
	    default 2 if ARM64_16K_PAGES && ARM64_VA_BITS_36
	    default 2 if ARM64_64K_PAGES && ARM64_VA_BITS_42
	    default 3 if ARM64_64K_PAGES && ARM64_VA_BITS_48
	    default 3 if ARM64_4K_PAGES && ARM64_VA_BITS_39
	    default 3 if ARM64_16K_PAGES && ARM64_VA_BITS_47
	    default 4 if !ARM64_64K_PAGES && ARM64_VA_BITS_48


	우리 본 코드 기준
	arch/arm/kernel/head.S
		mcr p15, 0, r4, c2, c0, 0       @ load page table pointer

	arch/arm/mm/proc-v7.S
	__v7_ca9mp_setup:
		v7_ttb_setup r10, r4, r8, r5        @ TTBCR, TTBRx setup
			mcr p15, 0, \zero, c2, c0, 2    @ TTB control register
				// ARM B3.5.4 Selecting between TTBR0 and TTBR1, Short-descriptor translation table format
				// split을 0 to 2**(32-N)-1 (N은 0~7). 즉 2G 아래로만 split이 가능하다. 커널이 arm이 만들어 놓은 목적대로 ttbr0,1을 사용하지 않는 이유.
			ALT_SMP(orr \ttbr0, \ttbr0, #TTB_FLAGS_SMP)
			ALT_SMP(orr \ttbr1, \ttbr1, #TTB_FLAGS_SMP)
			mcr p15, 0, \ttbr1, c2, c0, 1   @ load TTB1			// ttb1만 저장한다. swapper_pg_dir 백업

	arch/arm/mm/proc-v7-2level.S
	ENTRY(cpu_v7_switch_mm)
	새로운 mm으로 context를 시작하기 위해 TTB0와 context ID를 설정한다.
	mcr p15, 0, r0, c2, c0, 0       @ set TTB 0					// context switch에서 ttbr0를 current->mm.pgd로 교체.


	arch/arm/include/asm/mmu_context.h
		check_and_switch_context			// Required during context switch to avoid speculative page table walking with the wrong TTBR.

	secondary_startup
		ldr r4, [r7, lr]            @ get secondary_data.pgdir		// __cpu_up에서 준비해둠
		ldr r8, [r7, lr]            @ get secondary_data.swapper_pg_dir
		adr lr, BSYM(__enable_mmu)      @ return address
		ARM(   add pc, r10, #PROCINFO_INITFUNC ) @ initialise processor	// __v7_proc __v7_ca9mp_setup에서 v7_ttb_setup r8을 ttbr1.
	__enable_mmu:
		secondary_startup에서 r4: idmap_pgd (__turn_mmu_on ~ cpu_v7_reset 영역에 대해서만 매핑, early_initcall(init_static_idmap)에서.), r8: swapper_pg_dir이 들어간다.
					idmap_pgd = pgd_alloc(&init_mm);	// init_static_idmap()에서 호출되며, kernel 영역과 IO 영역의 page table을 복사한다.
		r8을 넣어준 위치는?
		mcr p15, 0, r4, c2, c0, 0       @ load page table pointer (TTB 0에 저장)
		b __turn_mmu_on
			__secondary_switched					// secondary_startup에서 들어올 때.
				b   secondary_start_kernel
					cpu_switch_mm(mm->pgd, mm);		// init_mm의 pgd는 swapper_pg_dir.
						cpu_v7_switch_mm
							mcr p15, 0, r0, c2, c0, 0       @ set TTB 0

	[참고자료]
		https://lkml.org/lkml/2013/6/26/544
		http://elinux.org/Tims_Notes_on_ARM_memory_allocation


	12-7 페이지 보는 중. 챕터 12.2
		https://community.arm.com/thread/5400



8.13
	64KB granule, 42-bit일 때 8192 entry.

	the page table entry refers to a 512MB page (it is a block descriptor).

	Because we have a 512MB page, bits [28:0] of the VA are taken to form PA[28:0]. 


	12.4.2 Effect of granule sizes on translation tables

	2level
	1. Granule과 VA를 먼저 설정한다.
		G=64KB, VA=42bit
	   VA의 [63:42]가 1이면 TTBR1, 0이면 TTBR0 
	2. contains 8192 64-bit page table entries, and is indexed via VA[41:29]. 
	   Bits [28:16] of the VA are used to index the level 3 page table entry.
	3. 64KB page [15:0]

		12.5.Virtual address cacheing 봄.

9.3 

	TTBR0_EL2
	Holds the base address of the translation table for the stage 1 translation of memory accesses from EL2.

	VTTBR_EL2
	Holds the base address of the translation table for the stage 2 translation of memory accesses from Non-secure EL0 and EL1.
		Guest OS에서 넘어온 IPA에 대한 PT.
		VMID: The VMID for the translation table.

	
	The SCTLR_ELn bits can be cached in a TLB entry. Therefore, changing the bit in the SCTLR might not affect entries already in the TLBs. When modifying these bits, a TLB invalidate and ISB sequence is necessary. 

	SCR 레지스터의 This bit is permitted to be cached in a TLB. ???


	arch/arm64/kernel/process.c tpidr context switch시 스위칭
	arch/arm64/mm/kernel.c

	12주 완료.



9.10
	ARM B2.8.2 memory type
	Strongly-ordered	Device-nGnRnE
	Device memory type	Device-nGnRE

	normal과 device 두 가지의 타입.
	“strongly ordered”와 device가 별 차이 없기 때문에 ARMv8에서는 없애버렸다.

	In addition to the memory type, attributes also provide control over cacheability, shareability, access, and execution permissions.
	Shareable and cache properties pertain only to Normal memory. Device regions are always deemed to be non-cacheable and outer-shareable. 


	The memory type is not directly encoded in the translation table entry.
	Instead, each block entry specifies a 3-bit index into a table of memory types.
	This table is stored in the Memory Attribute Indirection Register MAIR_ELn. 

	http://blog.tek-life.com/%E7%90%86%E8%A7%A3armv8-device-memory%E7%9A%84%E4%B8%89%E4%B8%AA%E5%B1%9E%E6%80%A7/
	This means that a DSB barrier, executed by the processor that performed the write to the No Early Write Acknowledgement location, completes only after the write has reached its endpoint in the memory system. Typically, this endpoint is a peripheral or physical memory.


	Load-Acquire (LDAR)
	All loads and stores that are after an LDAR in program order, and that match the shareability domain of the target address, must be observed after the LDAR.
		LDAR 다음의 모든 load와 store 명령들(target address와 shareability domain이 일치하는 것들)은 LDAR 다음에 관찰되게 한다.

	Store-Release (STLR)
	All loads and stores preceding an STLR that match the shareability domain of the target address, must be observed before the STLR.

	There are also exclusive versions of the above, LDAXR and STLXR, available.

	Unlike the data barrier instructions, which take a qualifier to control which shareability domains see the effect of the barrier,
	the LDAR and STLR instructions use the attribute of the address accessed.

	13.2.1 One-way barriers 보는 중
	page table entry에서 3bit가 MAIR의 index로 사용되는데, page table entry를 직접 확인해 봐야겠다.


9.24
	p.1774 Attribute fields in stage 2 VMSAv8-64 Block and Page descriptors
	Lower attributes
		SH, bits[9:8]		Shareability field,
		MemAttr, bits[5:2]	Stage 2 memory attributes,
		see The memory region attributes for stage 2 translations, EL1&0 translation regime on page D4-1786.

	An LDAR instruction guarantees that any memory access instructions after the LDAR, are only visible after the load-acquire.
	A store-release guarantees that all earlier memory accesses are visible before the store-release
	becomes visible and that the store is visible to all parts of the system capable of storing cached data at the same time.
		store-release는 
		그와 동시에 … 캐시된 데이터를 저장할 수 있는 시스템의 모든 부분에 대해 store를 visible 하게 한다.


	*** VA length와 Page size가 지정되면 translation level이 결정된다.
		L1 Translation으로 지정할 수 있는 block의 크기는?

		Figure 12-6 Translation table control register
		The two-bit Translation Granule (TG) TG1 and TG0 fields give the granule size for kernel or user space respectively, 00=4KB, 01=16KB, 11=64KB.

	13.3 Memory Attribute

	14.
		MPIDR_EL1
			; PG에는 MPDIR_EL3도 써두었는데, ARMv8 ARM에는 그런 이름이 없다.
			; ATF에서 plat 코드에 mpdir aff0은 cpu id를, aff1은 cluster id를 읽어올 때 사용하고 있다.

	여기보는 중
	Interrupt handling can also be load balanced across cores. This can help improve performance or save energy. Balancing interrupts across cores or reserving cores for particular types of interrupts can result in reduced interrupt latency. This might also result in reduced cache use which helps improve performance.

ARM p.1519
On taking an exception to AArch64 state:
• The PE state is saved in the SPSR_ELx at the Exception level the exception is taken to. See Saved Program Status Registers (SPSRs) on page D1-1506.
• The preferred return address is saved in the ELR_ELx at the Exception level the exception is taken to. See Exception Link Registers (ELRs) on page D1-1509.
• All of PSTATE.{D, A, I, F} are set to 1. See Process state, PSTATE on page D1-1511.
• If the exception is a synchronous exception or an SError interrupt, information characterizing the reason for the exception is saved in the ESR_ELx at the Exception level the exception is taken to. See Use of the ESR_EL1, ESR_EL2, and ESR_EL3 on page D1-1521.
• Execution moves to the target Exception level, and starts at the address defined by the exception vector. Which exception vector is used is also an indicator of whether the exception came from a lower Exception level or the current Exception level. See Exception vectors on page D1-1520.
• The stack pointer register selected is the dedicated stack pointer register for the target Exception level. See The stack pointer registers on page D1-1505.

D1.14 Asynchronous exception types, routing, masking and priorities
p.1553


10.01

	Timer
	CNTFRQ_EL0, Counter-timer Frequency register
		Holds the clock frequency of the system counter.
		It is only the register that is per-core
	CNTPCT_EL0, Counter-timer Physical Count register
		Holds the 64-bit physical count value.
	CNTKCTL_EL1 controls whether EL0 can access the system timer.


	SMP
		Symmetric Multi-Processing (SMP) is a software architecture that dynamically determines the roles of individual cores.
		Each core in the cluster has the same view of memory and of shared hardware.
	AMP
		An Asymmetric Multi-processing (AMP) system enables you to statically assign individual roles
		to a core within a cluster so that, in effect, you have separate cores, each performing separate jobs within each cluster. 


	14.3부터 볼차례…

10.22
	shareability attribute는 어디에 있나?
		D4.3.3 Memory attribute fields in the VMSAv8-64 translation table format descriptors
		lower attributes 중 SH, bits[9:8].
		Table D4-36 SH[1:0] field encoding for Normal memory, VMSAv8-64 translation table format

		The ARMv8 processors use the MOESI protocol. 


	http://egloos.zum.com/studyfoss/v/5144244
	http://jake.dothome.co.kr/cache4/
	http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dai0425/ch03s12s01.html


	A write can only be performed if the cache line is in a Modified or Exclusive state.
	If it is in a Shared state, all other cached copies must be invalidated first. A write moves the line into a Modified state.
		=> O 일 때는?

	A cache can discard a shared line at any time, changing it to an Invalid state. A Modified line is written back first.
		=> O 일 때는?

	If a cache holds a line in a Modified state, reads from other caches in the system receive the updated data from the cache.
	Conventionally, this is achieved by first writing the data to main memory and then changing the cache line to a Shared state, before performing a read.
		=> core 0은 Modified -> Owned
		   core 1은 Invalid -> Shared

	A cache that has a line in an Exclusive state must move the line to a Shared state when another cache reads that line.
		=> E 이었지만 다른 cache가 읽어가면 S로 바꾼다.

	A Shared state might not be precise. If one cache discards a Shared line,
	another cache might not be aware that it can now move the line to an Exclusive state.
		=> S였다가 그것을 버릴 때, 다른 cache는 E로 바뀔 수 있는데, 모를 수 있다.


	ACP는 SCU에 연결.
	When the FPGA-based accelerator produces a new result, the data needs
	to be passed back to the processor as quickly as possible, so that the processor can update its view of the data.

	The Accelerator Coherency Port (ACP) is an optional AXI 64-bit slave port that can be connected to non-cached
	AXI master peripherals, such as a DMAengine or cryptographic engine.

	ARM Cortex-A9 processor-based SoC FPGAs include a feature called an Accelerator Coherency Port (ACP).
	Through the ACP, new data produced by an FPGA-based hardware accelerator is transferred directly to the
	processor’s L2 cache, via a low-latency direct connection (Figure 1). This operation is performed not just
	quickly, but coherently too.
	=> cache에 있으면 cache 데이터를 쓰겠다.


	cluster 간을 포함한 다른 master 사이의 cache coherence는 CCI-400으로 한다.

	Extending hardware coherency to a multi-cluster system requires a coherent bus protocol.
	The AMBA 4 ACE specification includes the AXI Coherency Extensions (ACE).
	The full ACE interface enables hardware coherency between clusters and enables an SMP operating system to run on many cores.


10.29
	14.4.1 Compute subsystems and mobile applications 할 차례

	Idle state
	• Standby. - core is left powerf-up, and clock-gating. WFI나 WFE로 진입됨. retention과 유사. 
		The difference is evident to an external debugger and in hardware implementation,
	• Retention. (유지) - External Debug Request를 제외하고 standy와 유사하다.
	• Power down.
	• Dormant mode. (휴면)
		Dormant mode is an implementation of a power-down state. In dormant mode, the core logic is powered down, but the cache RAMs are left powered up. 
		Dormant mode is therefore much more likely to be useful in a single core environment rather than in a cluster.
	• Hotplug. - power down과 어떻게 다른가? 1,2번을 다 읽어도 확실하지 않은데, power down에서는 context를 저장하고 복원. hotplug는 secondary core 부팅하듯이..


	17. Security
	Only stage one translations are allowed in the Secure world and there is no TTBR1_EL3. 진짜? stage one만?
	The AArch64 EL1 translation table registers are not banked between security states and therefore the value of TTBR0_EL1, TTBR1_EL1,
	and TCR_EL1 must be saved and restored for each world as part of the Secure Monitor’s context switching operation. 


	17.1 TrustZone hardware architecture

		페이지 아래에서 밑에서 두 번째.
		TTBR1_EL3는 구조적으로 없다.
		TTBR0_EL1, TTBR1_EL1, and TCR_EL1 must be saved and restored for each world as part of the Secure Monitor’s context switching operation.
		

11.05
	17 나머지.
		ARMv7은 SCR (Secure Configuration Register) 레지스터의 NS 비트 설정.

		ARM ARM B1.5 The Security Extensions
			Changing from Secure to Non-secure state


* PERF/FTRACE 분석
		https://github.com/brendangregg/perf-tools

		ftrace, perf-events

		dtrace

	PERF
		http://www.brendangregg.com/perf.html
		https://perf.wiki.kernel.org/index.php/Main_Page
		https://www.youtube.com/watch?v=kWnx6eOGVYo
		
	책 - 주제에 해당하는 내용
		context switching
		timer (out of date - wheel)

	리눅스 API의 모든 것
	The Linux Programming Interface: A Linux and UNIX System Programming Handbook

	ftrace
	자격 증명 : 보안 관련된 것

* ftrace 기본 사용 방법

	mount -t debugfs nodev /sys/kernel/debug
	cd /sys/kernel/debug/tracing
	cat available_tracer
	echo function > ./current_tracer
	vi tracer
	echo function_graph > ./current_tracer


* 커널에서 FTRACE 사용하기

	Makefile의 내용 : 컴파일러 옵션을 통해 배니어 코드를 사용

	ifdef CONFIG_FUNCTION_TRACER
	KBUILD_CFLAGS   += -pg
	ifdef CONFIG_DYNAMIC_FTRACE
		ifdef CONFIG_HAVE_C_RECORDMCOUNT
			BUILD_C_RECORDMCOUNT := y
			export BUILD_C_RECORDMCOUNT
		endif
	endif
	endif

* [Linux Kernel Trace] 01_1 - ftrace 사용하기



	echo 'main(){}' | arm-linux-gnueabihf-gcc -x c -S -o output - -pg -static

	…
	main:
		push lr
		bl      __gnu_mcount_nc

	arch/arm64/kernel/stacktrace.c


	arch/arm/kernel/entry-common.S   : __gnu_mcount_nc
	arch/arm64/kernel/entry-ftrace.S : _mcount

	DYNAMIC_TRACE인 경우, nop을 타게 해뒀다가, tracer가 지정되면 nop을 바꿔치기 한다.
	arch/arm64/kernel/ftrace.c : ftrace_update_ftrace_func
		ftrace_stub

	mcount, tracepoint, kprobees

	- mcount : -pg를 통해 함수 호출시마다 bl _mount. arm의 경우 entry-common.S에 mcount 구현. tracer에 따라 동작
	- tracepoint : 
		https://www.kernel.org/doc/Documentation/trace/tracepoints.txt
		https://www.kernel.org/doc/Documentation/trace/tracepoint-analysis.txt
	- kprobes : __arm_kprobe() 함수를 호출하여 원래의 opcode를 breakpoint instruction (int3)으로 교체한다.
	  (kprobe, jprobe, kretprobe)

		멀티프로세싱 시스템에서 지역적으로 메모리를 공유하여 bottleneck
		NUMA SMP 시스템의 클러스터들 사이에 있는 버스에서는 SCI (scalable coherent interface) 기술을 사용하여 데이터가 움직인다. SCI는 다중 클러스터의 노드에 걸쳐 캐시 일관성이라고 불리는 것과 대등하다.
AMP : 두 개 이상의 프로세서가 각각 자신만의 특정 기능을 수행하는 아키텍쳐. 
  예를 들어 하나의 프로세서가 메인 운영체제를 실행하고, 다른 프로세서는 I/O 오퍼레이션 기능을 수행하는 형태.
  이 때, 두 개의 프로세서는 메인 메모리에서 자신의 커널 이미지를 실행하고 주소 공간 역시 분리되어 있는 컨셉.
  (커널은 동일한 커널을 사용할 수도, 다른 커널을 사용할 수도 있다)


heterogeneous multi-core

intel developers guide
www.coreboot.org

- 특정 디렉토리 (모듈) 빌드
	make SUBDIRS=drivers/block/company modules

- 빌드시 전체 중간파일 생성
	KBUILD_CFLAGS에 -save-temps=obj 추가

- dump 파일 생성 (d: dump, S: full contents, s: source, l:line number, x: all-headers)
	arm-linux-gnueabihf-objdump -ds vmlinux > vmlinux.txt

- 커널 분석 후 각 디렉토리에 build시 사용된 command가 남아 있다.
	vi .vmlinux.cmd

http://lwn.net/Articles/322666/
http://lwn.net/Articles/365835/
http://lwn.net/Articles/366796/
http://lwn.net/Articles/370423/

http://events.linuxfoundation.org/slides/2010/linuxcon_japan/linuxcon_jp2010_rostedt.pdf

http://www.kandroid.org/board/board.php?board=conference&command=body&no=81

- kernel internal operation tracer
- kenrel 분석시 종종 봤던 trace 관련 함수들이 이런 분석을 위한 것이었구나
- sys/debugfs를 사용하는 것으로 보아 runtime시에 직접 확인할 수 있는 것이었구나.

- config의
“Kernel hacking”
	“Tracers”

file:///Users/freestyle/Downloads/30.kandroid-8th-debugging-ftrace-20111016-1550.pdf

TREE - rbtree

	http://thesoul214.tistory.com/113
	http://blog.secmem.org/177

	http://ko.wikipedia.org/wiki/%EB%A0%88%EB%93%9C-%EB%B8%94%EB%9E%99_%ED%8A%B8%EB%A6%AC
	http://en.wikipedia.org/wiki/Red%E2%80%93black_tree
	http://sweeper.egloos.com/900135


TREE - ast-tree
	http://talkingaboutme.tistory.com/514
	https://www.google.co.kr/#newwindow=1&q=ast+tree


LIST - doubly linked list

HLIST

DMA Engine != DMA mapping

* architecture specific
#include <asm/cacheflush.h>
#include <asm/outercache.h>


* DMA Mapping API

linux/dma-mapping.h
│
├─ linux/dma-attrs.h
├─ linux/dma-direction.h
├─ linux/scatterlist.h
│
#ifdef CONFIG_HAS_DMA
└─ asm/dma-mapping.h
#else
└─ asm-generic/dma-mapping-broken.h
#endif

linux/dma-mapping.h
│
├─ linux/dma-attrs.h
├─ linux/dma-direction.h
├─ linux/scatterlist.h
│
└─ arch/arm/include/asm/dma-mapping.h
 │
 ├─ asm-generic/dma-mapping-common.h
 └─ asm-generic/dma-coherent.h

struct dma_map_ops arm_dma_ops = {
	.alloc		= arm_dma_alloc,
	.free		= arm_dma_free,
	.mmap		= arm_dma_mmap,
	…
};

percpu first chunk를 lowmem에 위치 <- 다른 node에 있어서 느리지 않냐?
CPU수만큼 copy.
numa는 dynamic chunk를 numa에 위치.

39bit

SMP

o percpu

o spinlock
	if (smp)	// spinlock_api_smp.h
		preempt_disable();
		do_raw_spin_lock();
	else		// spinlock_api_up.h
		preempt_disable();

o smp_mb() ? dmb() : barrier()

o preempt_count
	#define inc_preempt_count() add_preempt_count(1)
  	# define add_preempt_count(val) do { preempt_count() += (val); } while (0)
	#define preempt_count() (current_thread_info()->preempt_count)

o barrier()	/* compiler optimize barrier */
	#define barrier() __asm__ __volatile__("": : :"memory")

struct task_struct {
	. . .
	void *stack;
	. . .
}

/* task_struct -> thread_info */
#define task_thread_info(task)  ((struct thread_info *)(task)->stack)

union thread_union {
	struct thread_info thread_info;
	unsigned long stack[THREAD_SIZE/sizeof(long)];
};

o arch/arm/include/asm/thread_info.h
static inline struct thread_info *current_thread_info(void)
{
	register unsigned long sp asm ("sp");
	return (struct thread_info *)(sp & ~(THREAD_SIZE - 1));
}

    ZONE_MOVABLE

* zone_movable이란? page 단편화을 처리할 수 있게 움직일 수 있는 page.
* user page는 거의 다 movable table
* zone_movable의 크기는?
* NUMA…

    SPINLOCK

    completion

wait_for_completion()
	waits for completion of a task
wait_for_completion_timeout()
	waits for completion of a task (w/timeout)

    compiler syntax

o <linux/compiler.h>

o __typeof__
	expression의 type을 참조한다.

    per-CPU allocator

#include <linux/percpu.h>

o 정적 per-CPU 변수 선언
	DEFINE_PER_CPU(type, name)
o 정적 per-CPU 변수 접근
	get_cpu_var(sockets_in_use)++;
	put_cpu_var(sockets_in_use);
o 다른 cpu의 per-CPU 변수 접근
	per_cpu(variable, int cpu_id);			// 변수를 전달받아 변수를 리턴하는 인터페이스


o 동적 per-CPU 변수 선언
	void *alloc_percpu(type);
	void *__alloc_percpu(size_t size, size_t align);
o 동적 per-CPU 변수 해제
	free_percpu
o 동적 per-CPU 변수 사용
	per_cpu_ptr(void *per_cpu_var, int cpu_id);	// 포인터를 전달받아 포인터를 리턴하는 인터페이스

o __this_cpu_ptr
setup_per_cpu_area에서 채운 __per_cpu_offset에서 현재의 processor id로 값을 찾아온다.


o 동적 변수를 접근할 때 사용하는 per_cpu_ptr을 분석해 보자.

    kmem_cache

    RCU (read, copy, update)

동기화 매커니즘(synchronization mechanism)의 하나.
하나의 updater와 concurrent하게 reader들을 동작하도록 하여 시스템의 scalability를 향상시키는 lock free 메커니즘이다.
	* 주의 : updater들간의 동기화는 보장하지 않는다. 즉 updater간 별도의 동기화 매커니즘이 필요하다.

주로 읽기 연산만 일어나고, 쓰기 연산은 거의 일어나지 않는 객체에 주로 쓰인다.
Reader-Writer lock과 유사하지만, 읽기시에 block이 발생하지 않고(wait-free) 오버헤드가 극도로 작다.
반면 쓰기 연산의 오버헤드는 크다. 쓰기에 필요한 동기화의 시간 복잡도가 RCU로 보호되는 객체의 크기에 비례해 커진다.


기본 원리
1. Publish-Subscribe mechanism (리더 접근. 삭제)
	; publish - rcu_assign_pointer(), subscribe - rcu_dereference()
2. Wait For Pre-Existing RCU Readers to Complete (업데이터. 삭제)
	; destructive operation
3. Maintain Multiple Versions of Recently Updated Objects (리더 접근.)


example)
rcu_read_lock(void)
rcu_dereference()
rcu_read_unlock(void)



1. Publish-Subscribe mechanism (for insertion)

	Category | Publish			Retract					Subscribe

	Pointers | rcu_assign_pointer()		rcu_assign_pointer(..., NULL)		rcu_dereference()

	Lists	 | list_add_rcu()		list_del_rcu()				list_for_each_entry_rcu()	
		   list_add_tail_rcu()
		   list_replace_rcu()

	Hlists   | hlist_add_after_rcu()	hlist_del_rcu()				hlist_for_each_entry_rcu()
		   hlist_add_before_rcu()
		   hlist_add_head_rcu()
		   hlist_replace_rcu()


2. Wait For Pre-Existing RCU Readers to Complete (for delete)

	RCU를 사용하는 가장 큰 목적은 performance degradation이나 scalability에 대한 제한,
	복잡한 deadlock problem이나 메모리 leak hazard와 같은 문제점에 대한 걱정 없이 사용할 수 있다.


	* destructive operation이 두 단계(phase)로 나뉘는 게 rcu의 핵심이다.
	removal phase : 제거될 data에 대한 새로운 참조를 막는다. 새로운 버전의 data에는 접근 가능하다.
			단 각 data에 대한 참조는 중간 상태를 허용하지 않는다.
			이것이 reader의 동시접근이 가능한 이유이다.
	reclamation phase : 이전 data에 대한 메모리 해제 단계.
			reader의 이전 data에 대한 참조가 모두 끝나기 전까지 reclamation phase는 시작되지 않는다.

	updater에 의해 removal phase는 바로 실행될 수 있는 반면,
	reclamation phase는 removal phase 동안 active 되어 있는 reader가 완료될 때까지 연기된다.
	즉, reader가 critical section을 빠져나갔음을 block 상태로 대기하거나 callback을 등록하여 알 수 있어야 한다.

	하지만 rcu_read_lock(), rcu_read_unlock()은 단지 preempt_disable()/preempt_enable()일 뿐이며
	non-PREEMPT일 경우 어떤 코드도 생성하지 않는다. 따라서 reader가 임계구역을 빠져나갔는지 알 수 있는 방법이 없다.

	대신 전통적인 rcu에서는 이 read-side 임계구역에서 sleep이나 block이 발생할 수 없다는 특징을 이용해 context switching이 발생하면
	임계구역을 벗어났다고 판단한다. 따라서 모든 cpu에서 한 번 이상 context switching이 발생했다면 read-side 임계구역이 끝났다고 할 수 있다.

	하지만 interrupt, NMI, CPU hotplug 등에 의해 실제 구현은 더 복잡하다. 또한 RT는 보다 복잡해 다른 접근을 필요로 한다.


3. Maintain Multiple Versions of Recently Updated Objects (for readers)








주요 API

	http://lwn.net/Articles/264090/

	The core RCU API is quite small:
	a.  rcu_read_lock()
	b.  rcu_read_unlock()
	c.  synchronize_rcu() / call_rcu()
	d.  rcu_assign_pointer()
	e.  rcu_dereference()



	1. 할당
	rcu_assign_pointer() - assign to RCU-protected pointer
		ensuring that any concurrent RCU readers will see any prior initialization.
		(새로운 structure를 publication 한다)



	rcu_read_lock()			; current의 rcu_read_lock_nesting 증가, barrier
		rcu_dereference() - publish된 값을 읽는다.
	rcu_read_unlock()

	RCU는 update와 reader들 사이에 concurrency를 향상시키는 것. update들 간에  concurrency를 보장하는 매커니즘이 아니다.


	* update-side primitives
		synchronize_rcu() - Wait For Pre-Existing RCU Readers to Complete
			PREEMPT_RCU인 경우 : call_rcu
			non-PREEMPT RCU인 경우 : synchronize_sched
		call_rcu() 
		


용어
srcu : sleepable RCU


위치
include/linux/rcupdate.h
	rcu_read_lock
	rcu_assign_pointer
include/linux/rculist.h
	list_for_each_entry_rcu
kernel/rcutiny.c
kernel/rcutree.c



[참고]
	barrios RCU
	http://www.rdrop.com/users/paulmck/RCU/whatisRCU.html
	http://summerlight.tistory.com/11


* Grace Period
	rcu_start_gp
		rsp->gpnum++;

		rcu_for_each_node_breadth_first(rsp, rnp) {
			rnp->gpnum = rsp->gpnum;

	note_new_gpnum
		__note_new_gpnum
			rdp->gpnum = rnp->gpnum;

    completion

[자료] https://www.linux.co.kr/home/lecture/index.php?cateNo=&secNo=&theNo=&leccode=11129

task 사이의 ‘complete’ 이벤트를 보장하기 위한 동기화 매커니즘.
‘complete’이벤트를 기다리는 task는 sleep 상태로 대기하므로 interrupt context에서 사용될 수 없다.

completion이 먼저 호출되었다면 이미 완료되었으므로 scheduling 되지 않고 바로 리턴한다.


struct completion completion;

init_completion(&completion);
wait_for_completion(&completion);

/* kernel/sched/core.c */
complete(&complete);		// 하나의 task만 깨운다.
complete_all(&complete);	// 큐에 대기 중인 모든 task를 깨운다.

See also:  complete(), wait_for_completion() (and friends _timeout,
 _interruptible, _interruptible_timeout, and _killable), init_completion(),
 and macros DECLARE_COMPLETION(), DECLARE_COMPLETION_ONSTACK(), and INIT_COMPLETION().

    bitops

#include <linux/bitops.h>
#include <asm/bitops.h>		/* architecture specific, linux에서 include함 */

arch/arm/include/asm/bitops.h
o set_bit류
	#define set_bit(nr,p)           ATOMIC_BITOP(set_bit,nr,p)
	#define clear_bit(nr,p)         ATOMIC_BITOP(clear_bit,nr,p)
	#define change_bit(nr,p)        ATOMIC_BITOP(change_bit,nr,p)
o fls류
o find류
	find_first_zero_bit -> _find_first_zero_bit_le

o test_and_set_bit류


arch/arm/lib/ 아래
	bitops.h          ; bitop, testop assembly macro 선언 아래 assem routine에서 include
	changebit.S       ; bitop   _change_bit, eor
	clearbit.S        ; bitop   _clear_bit, bic
	setbit.S          ; bitop   _set_bit, orr
	testchangebit.S   ; testop  _test_and_change_bit, eor, str
	testclearbit.S    ; testop  _test_and_clear_bit, bicne, strne
	testsetbit.S      ; testop  _test_and_set_bit, orreq, streq

	findbit.S
	_find_first_zero_bit_le
	_find_next_zero_bit_le
	_find_first_bit_le
	_find_next_bit_le

syscall (system call)

arch/arm/kernel/entry-common.S
	    .equ NR_syscalls,0
	#define CALL(x) .equ NR_syscalls,NR_syscalls+1		// NR_syscalls가 CALL 선언된 수만큼 증가한 최종값으로 선언.
	#include "calls.S"

arch/arm/kernel/calls.S
	CALL(sys_restart_syscall)
	CALL(sys_exit)
	…

include/linux/syscalls.h - Linux syscall interfaces (non-arch-specific)
	…
	#define SYSCALL_DEFINE3(name, ...) SYSCALL_DEFINEx(3, _##name, __VA_ARGS__)

	#define SYSCALL_DEFINEx(x, sname, ...)              \
	    __SYSCALL_DEFINEx(x, sname, __VA_ARGS__)

	#define __SYSCALL_DEFINEx(x, name, ...)
	    asmlinkage long sys##name(__SC_DECL##x(__VA_ARGS__))

	asmlinkage long sys_ioctl(unsigned int fd, unsigned int cmd,
	                unsigned long arg);


fs/ioctl.c
	#include <linux/syscalls.h>
	SYSCALL_DEFINE3(ioctl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)





* system call 선언 위치 찾기
	1) arch/arm/kernel/calls.S 에서 목록 확인
	
	2-1) System.map 에서 symbol 이름으로 찾기
	$ arm-linux-gnueabihf-addr2line —f e vmlinux 800b5c54
	sys_read
	/home/freestyle/kernel/iamroot9C/fs/read_write.c:463

	2-2 make ARCH=arm tags
	:tj sys_read

* system call trace
	$ strace ./user_program






* ARM Exception Vector Table (low/high)

Exception			Entry Mode
———————————————————————————————
Reset				SVC
Undefined Instruction		UNDEF
Software Interrupt		SVC
Prefetch Abort			ABT
Data Abort			ABT
Reserved			Reserved
IRQ				IRQ
FIQ				FIQ		


* arch/arm/kernel/entry-armv.S
==============================
.LCvswi:
    .word   vector_swi				// vector_swi의 주소

	…

    .globl  __vectors_start
__vectors_start:
 ARM(   swi SYS_ERROR0  )
 THUMB( svc #0      )
 THUMB( nop         )
    W(b)    vector_und + stubs_offset
    W(ldr)  pc, .LCvswi + stubs_offset		//<- svc(=swi) 호출시 vector_swi 주소를 pc에 저장
    W(b)    vector_pabt + stubs_offset
    W(b)    vector_dabt + stubs_offset
    W(b)    vector_addrexcptn + stubs_offset
    W(b)    vector_irq + stubs_offset
    W(b)    vector_fiq + stubs_offset
==============================


* arch/arm/kernel/entry-common.S
==============================
ENTRY(vector_swi)
    sub sp, sp, #S_FRAME_SIZE
    stmia   sp, {r0 - r12}          @ Calling r0 - r12
 ARM(   add r8, sp, #S_PC       )
 ARM(   stmdb   r8, {sp, lr}^       )   @ Calling sp, lr
    mrs r8, spsr            @ called from non-FIQ mode, so ok.
    str lr, [sp, #S_PC]         @ Save calling PC
    str r8, [sp, #S_PSR]        @ Save CPSR
    str r0, [sp, #S_OLD_R0]     @ Save OLD_R0
    zero_fp
	…
    adr lr, BSYM(ret_fast_syscall)  @ return address
    ldrcc   pc, [tbl, scno, lsl #2]     @ call sys_* routine	//<- syscall 호출 후 ret_fast_syscall

	…

ret_fast_syscall:
	…
    bl  do_work_pending			//<- if (likely(thread_flags & _TIF_NEED_RESCHED)) schedule();
==============================




* user program에서 syscall 호출코드 찾기

==============================
#define _GNU_SOURCE      /* or _BSD_SOURCE or _SVID_SOURCE */
#include <unistd.h>
#include <sys/syscall.h> /* For SYS_xxx definitions */
#include <sys/types.h>   /* For pid_t */

static inline pid_t my_gettid (void)
{
    return (pid_t) syscall (SYS_gettid); /* or __NR_gettid */
}
==============================

	${CROSS_COMPILE}gcc -o ex ex.c -static
	${CROSS_COMPILE}objdump -dSlx ex | cat > ex_dump.txt

	1) glibc에 의한 system call
		__libc_do_syscall()에서  ‘svc 0’

	2) syscall에 의한 호출
		syscall()에서 ‘svc 0’

    Virtual Process Memory

struct mm_struct	; memory management information for the process.
struct vm_area_struct	; 

    Kernel Memory Layout on ARM Linux

    Russell King <[email protected]>
         November 17, 2005 (2.6.15)

- kmem_cache_create, kmem_cache_alloc, kmem_cache_free, kmem_cache_destroy
	/proc/slabinfo
	struct kmem_cache
- 동작 메모리 할당(kmalloc, vmalloc, __get_page_size?)과 회수시, 메모리 부족시에 어떻게 동작하는가?

o function call trace
	kernel/list.txt에 정리
	Ftrace
o UML로 call routine 정리

__HEAD           <- .section    ".head.text","ax"

.align  

.text   



.data   
.globl  __pv_phys_offset
.type   __pv_phys_offset, %object                                                                                                                         

b   2f                                                                                                                                                    

  This can only be used with non-XIP MMU kernels where the base 
  of physical memory is at a 16MB boundary.

  Only disable this option if you know that you do not require
  this feature (eg, building a kernel for a single machine) and
  you need to shrink the kernel to the minimal size.

    physical = virtual + (PHYS_OFFSET - PAGE_OFFSET)
    virtual = physical - (PHYS_OFFSET - PAGE_OFFSET)

str r8, [r7]        @ save computed PHYS_OFFSET to __pv_phys_offset
mov r6, r3, lsr #24 @ constant for add/sub instructions @ r6에 (PHYS_OFFSET - PAGE_OFFSET) 상위 한 바이트
teq r3, r6, lsl #24 @ must be 16MiB aligned
bne __error
str r6, [r7, #4]    @ save to __pv_offset
b   __fixup_a_pv_table

.align

.data
.globl  __pv_phys_offset
.type   __pv_phys_offset, %object

  struct cgroup_subsys cpuset_subsys = {
    .base_cftypes = files;    /* struct cftype files. */
  };
*/

R0 => 0
R1 => machine type
R2 => ATAG의 base address
  		Physical memory address (mandatary)

208 static struct mem_type mem_types[] = {
209     [MT_DEVICE] = {       /* Strongly ordered / ARMv6 shared device */
210         .prot_pte   = PROT_PTE_DEVICE | L_PTE_MT_DEV_SHARED |
211                   L_PTE_SHARED,
212         .prot_l1    = PMD_TYPE_TABLE,
213         .prot_sect  = PROT_SECT_DEVICE | PMD_SECT_S,
214         .domain     = DOMAIN_IO,                                                                                                                                            
215     }, 

                                 지역 변수 this_start, this_end의 주소를 넣는다

                       ?, 1,    0,      memblock.current_limit, NULL

             i = (u64)ULLONG_MAX
                       &i, 1, &this_start, &this_end, NULL

set_pageblock_flags_group을 호출
  PB_migrate ~ PB_migrate_end (0~2)사이
    bitidx (page block nr에 해당하는 index) + start_bitidx로 비트위치를 찾아
    flag인 비트는 set, 그 외는 clear. 여기서 flags는 MIGRATE_MOVABLE이다.

for (sft = 32; sft > 0; sft--) {
    tmp = (u64) to << sft;
    tmp += from / 2;
    do_div(tmp, from);
    if ((tmp >> sftacc) == 0)
        break;
}

m / (1000 / 100) = m / 1000 * 100 = 초 * (1/주기) 몇 tick이냐...


timers/highres.txt 는 뭐야?

    pcpu_build_alloc_info(reserved_size, dyn_size, atom_size)
        ai = pcpu_alloc_alloc_info()
        /* ai의 멤버를 채운다. */

        for (0 ~ nr_groups) /* ai->groups[group] 을 순회하며 각 gi를 채운다. */
    size_sum = ai->static_size + ai->reserved_size + ai->dyn_size;
    areas_size = PFN_ALIGN(ai->nr_groups * sizeof(void *));
    areas = alloc_bootmem_nopanic(areas_size);

    /* allocate, copy and determine base address */
for (0 ~ nr_groups)
        
    /*
     * Copy data and free unused parts.  This should happen after all
     * allocations are complete; otherwise, we may end up with
     * overlapping groups.
     */
for (0 ~ nr_groups)

    /* base address is now known, determine group base offsets */
for (0 ~ nr_groups)

    rc = pcpu_setup_first_chunk(ai, base);  /* 아래에 정리 */

delta = (unsigned long)pcpu_base_addr - (unsigned long)__per_cpu_start;
for_each_possible_cpu(cpu)
    __per_cpu_offset[cpu] = delta + pcpu_unit_offsets[cpu];
    /* 여기서 per_cpu_offset(x)으로 찾아 쓸 값을 설정한다. */

* __schedule
	context_switch
		prepare_task_switch
		switch_mm
		switch_to
		finish_task_switch

* __schedule 을 호출하는 함수들
	schedule
	preempt_schedule
	preempt_schedule_irq
	__cond_resched	<- _cond_resched에서 should_resched()일 때. <- cond_resched <- 

preempt_enable()
	: preempt_disable에 대응되어 선점 가능 상태로 만든다.

	preempt_enable_no_resched();
	barrier();
	preempt_check_resched();	// 선점불가 상태에서는 바로 리턴된다.

might_sleep
	: "explicit preemption points"를 더 많이 두어 latency를 줄이고자 할 때 사용.
	  시간이 많이 걸리는 작업 전에 자발적으로 스케쥴링을 실행

	# define might_sleep() do { might_resched(); } while (0)
	# define might_resched() _cond_resched()

need_resched
	: thread_info에서 resched flag를 검사해 scheduling이 필요한지 검사하는 함수

	return unlikely(test_thread_flag(TIF_NEED_RESCHED));

should_resched
	: 현재 task가 스케쥴링 되어야 하며 선점 중이 아닌지 검사.

	return need_resched() && !(preempt_count() & PREEMPT_ACTIVE);

__cond_resched
	: 현재 task가 선점 중임을 표시하고, 스케쥴러를 호출한다.

	add_preempt_count(PREEMPT_ACTIVE);
	__schedule();
	sub_preempt_count(PREEMPT_ACTIVE);

_cond_resched
	: resched

	if (should_resched()) {
		__cond_resched();
		return 1;
	}
	return 0;

kernel 선점
	: __irq_svc (supervisor 상태에서 irq 발생)에서 irq_handler 처리 후,
	  TIF_NEED_RESCHED 되어야 한다면 svc_preempt로 처리한다.

	svc_preempt:
		preempt_schedule_irq	// 선점불가 상태에서는 바로 리턴된다.

sort(&meminfo.bank, meminfo.nr_banks, sizeof(meminfo.bank[0]), meminfo_cmp, NULL);
sanity_check_meminfo();
arm_memblock_init(&meminfo, mdesc);

paging_init(mdesc);

...

bank들을 순회하며 아래 조건이 성립하면 highmem을 설정
if (bank->start > ULONG_MAX)
    highmem = 1;

CONFIG_HIGHMEM일 경우 아래 경우도 체크
if (__va(bank->start) >= vmalloc_min ||			/* vmalloc_min : (void *)(VMALLOC_END - (240 << 20) - VMALLOC_OFFSET); */
    __va(bank->start) < (void *)PAGE_OFFSET)	/* PAGE_OFFSET (VA) */
    highmem = 1;

bank->highmem = highmem;

if ((!bank->highmem) && (bank->start + bank->size > arm_lowmem_limit))
    arm_lowmem_limit = bank->start + bank->size;	/* bank의 끝 주소 중 가장 큰 값 */

순회 끝난 뒤
high_memory = __va(arm_lowmem_limit - 1) + 1;

  Depending on the selected kernel/user memory split, minimum 
  vmalloc space and actual amount of RAM, you may not need this
  option which should result in a slightly faster kernel. 

  If unsure, say n.

*    pgd             pte
* |        |
* +--------+
* |        |       +------------+ +0
* +- - - - +       | Linux pt 0 |           <- 이건 뭐로 참조하나? 언제 또 쓰일 거냐?
* |        |       +------------+ +1024
* +--------+ +0    | Linux pt 1 |
* |        |-----> +------------+ +2048
* +- - - - + +4    |  h/w pt 0  |
* |        |-----> +------------+ +3072
* +--------+ +8    |  h/w pt 1  |
* |        |       +------------+ +4096

.align

bic r3, r9, #0x00ff0000
bic r3, r3, #0x0000000f @ mask 0xff00fff0
mov r4, #0x41000000
orr r4, r4, #0x0000b000
orr r4, r4, #0x00000020 @ val 0x4100b020
teq r3, r4          @ ARM 11MPCore?
moveq   pc, lr          @ yes, assume SMP

mrc p15, 0, r0, c0, c0, 5   @ read MPIDR
and r0, r0, #0xc0000000 @ multiprocessing extensions and
teq r0, #0x80000000     @ not part of a uniprocessor system?
moveq   pc, lr          @ yes, assume SMP

alloc_node_mem_map에서 pfn 크기만큼 메모리를 할당받아 map에 저장하고, 그 값을 node_mem_map에 넣는다.

o _count 필드는 페이지의 사용횟수, 즉 해당 페이지에 대한 참조가 얼마나 되는지를 저장한다.
  현재 page_count는 _count를 읽어 바로 리턴한다.

o _count is a usage count indicating the number of references to this page in the kernel. When its value reaches 0, the kernel knows that the page instance is not currently in use and can therefore be removed. If its value is greater than 0, the instance should on no account be removed from memory. If you are not familiar with reference counters, you should consult Appendix C for further information.

0) callback function을 우선순위에 따라 리스트로 등록해두고,
  이벤트가 발생하면 등록된 callback 함수들을 호출하는 매커니즘
1) struct notifier_block을 선언한다.
2) notifier_block을 등록한다.
3) 등록/호출
  * register 함수 : notifier_chain_register
	notifier head를 따라가 priority순으로 정렬된 위치에 notifier_block을 달아준다.
	notifier chain은 별도의 head를 둔 싱글 리스트이며, 리스트는 RCU-protected pointer로 관리된다.
  * unregister 함수 : notifier_chain_unregister
  * call 함수 : notifier_call_chain

4) 보통 전역변수로 notifier_chain *head를  선언하고, 독자적인 함수로 등록한다.
	등록 : register_cpu_notifier
	호출 : cpu_notify
	cpu_chain이라는 notifier head에 notifier_block을 등록한다.

	notifier head는 다음과 같이 선언한다.
	static RAW_NOTIFIER_HEAD(cpu_chain);

	RAW_NOTIFIER_HEAD는 구조체 변수를 선언하고, 멤버인 .head를 초기화 하는 매크로이다.

	  #define RAW_NOTIFIER_HEAD(name)                 \
	      struct raw_notifier_head name =             \
	          RAW_NOTIFIER_INIT(name)

	  struct raw_notifier_head {
	      struct notifier_block __rcu *head;
	  };



struct notifier_block
	int (*notifier_call)()
	struct notifier_block __rcu *next;
	int priority;

head : type에 따라 각각 다른 head와 api가 존재한다.
	위치: kernel/notifier.c

	struct atomic_notifier_head   : spinlock을 포함하는 atomic 버전
	struct blocking_notifier_head : rwsem을 포함하는 blocking 버전
	struct raw_notifier_head      : 특별한 기능을 포함하지 않는 raw 버전
	struct srcu_notifier_head     : sleeping rcu을 포함하는 srcu 버전

get_page_from_freelist
	buffered_rmqueue
		prep_new_page

* kmap (arch/arm/mm/highmem.c)

kmap/kunmap은 highmem 페이지들을 커널의 virtual address space에 맵핑/해제할 때 사용된다.
커널에 있어서의 관심사항이다. 유저스페이스의 프로세스에게는 highmem이든 normal page든 page table을 거쳐가기 때문이다.
	- from ‘Professional Linux Kernel Architecture’

pages_alloc 등을 통해 페이지프레임을 얻어와 가상 주소를 kmap을 호출해 
	사용방법 vaddr = kmap(page_ptr)
	http://kldp.org/node/137435


매핑함수

kmap			; 
	- kmap_high	; page에 대한 VA가 존재하면 바로 리턴, 없으면 map_new_virtual을 호출해 리턴.
			  새로 매핑이 불가능할 경우 sleep하므로 interrupt context에서 사용할 수 없다.
		- map_new_virtual
			- set_pte_at (pkmap_page_table에 매핑. pkmap_page_table은 kmap_init에서 할당해둠)
				- set_pte_ext
kmap_atomic		; interrupt context에서 사용 가능 - sleep 하지 않다.
	- set_top_pte (Fixmap address)


조회 함수

kmap_high_get		; 페이지 포인터를 받아 high memory에 맵핑 되어 있으면 VA를 리턴하고, 아니면 NULL을 리턴한다.




관련문서
	kmap_atomic
	Good SMP scalability can be obtained by using kmap_atomic(), which is lockless. 
	http://linux-mm.org/HighMemory

	Understanding the Linux Kernel 8.1.6 Kernel Mappings of High-Memory Page Frames
	Documentation/arm/memory.txt
	Documentation/vm/highmem.txt

PKMAP_BASE는 kernel 영역 시작주소 - PMD(2MB).

free pages > pages_high - 메모리가 충분하다.

free pages < pages_low - 하드 디스크로 swap out을 시작한다.

free pages < pages_min - 페이지 회수를 강하게 실시한다.

current->flags |= PF_MEMALLOC;		// task의 flags에 설정한다. Process Flag. 선언위치도 include/linux/sched.h.

try_to_free_pages();

current->flags &= ~PF_MEMALLOC;

if (current->flags & PF_MEMALLOC)	// 이미 reclaim이 실행 중이라면 재귀 호출을 막기 위해 nopage로 이동한다.
	goto nopage;

Professional Ch.3의 Memory Zones를 보면 나와 있다.

putback_lru_page
	if page가 evictable하다면
		lru_cache_add_lru (active lru에 넣어준다)

page flags의 enum type.
	PG_active flag에 대한 function : PageActive, SetPageActive, ClearPageActive
	PG_referenced

kmap_high_get			// page가 매핑 되었다면 매핑된 VA를 리턴. pkmap_count++

kmem_cache_alloc
create_kmalloc_cache("kmalloc-96”)
create_kmalloc_cache("kmalloc-192”)
create_kmalloc_cache("kmalloc”)		// 2의 배수

	early_kmem_cache_node_alloc	// slub allocator가 초기화 되기 전에는 직접 호출
		new_slab		// struct page * 리턴. 
			allocate_slab	// slab을 할당한다.
				alloc_slab_page	// page allocator로부터 page를 할당
			inc_slabs_node

- page->freelist = start;	// 첫번째 free object의 위치로 설정
- page->inuse = page->objects;	// inuse는 사용 중인 object의 개수
- page->frozen = 1;		// 최초에 frozen

pcpu_size_to_slot 는 chunk의 free_size로 slot index를 반환한다.
할당/해제가 이루어질 때마다 pcpu_chunk_relocate가 호출되어 필요한 경우 chunk가 연결되는 slot을 갱신한다.

 [*|*][*|*][*|*][*|*][*|*] . . . [*|*]

— vmalloc은 percpu 분석 후 분석하기로 함 -

preemption enable 상태, interrupt disable 상태 (spinlock을 사용하지는 않았음)

init_kmem_cache_nodes에서는 slab_state가 DOWN인 경우
	early_kmem_cache_node_alloc으로 node를 받아온다.



virt_to_head_page
	: object가 속해 있는 slab을 리턴한다.
	: slab instance를 struct page*로 표현한다.
new_slab
slab_alloc
slab_free

struct kmem_cache 자체도 slub allocator를 통해 할당 받는다.
하지만 아직 slub allocator를 사용할 수 없으므로, kmem_cache_open을 통해 초기화 한다.

/* kmem_cache_open for slab_state == DOWN. */
kmem_cache = (void *)__get_free_pages(GFP_NOWAIT, order);	// buddy로부터 메모리 할당

kmem_cache_node = (void *)kmem_cache + kmalloc_size;

kmem_cache_open(kmem_cache_node, "kmem_cache_node",		// kmem_cache_open으로 kmem_cache_node를 관리하는 struct kmem_cache 초기화
    sizeof(struct kmem_cache_node),
    0, SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);

slab_state = PARTIAL;

temp_kmem_cache = kmem_cache;
kmem_cache_open(kmem_cache, "kmem_cache", kmem_size,
    0, SLAB_HWCACHE_ALIGN | SLAB_PANIC, NULL);
kmem_cache = kmem_cache_alloc(kmem_cache, GFP_NOWAIT);		// slab instance 생성
memcpy(kmem_cache, temp_kmem_cache, kmem_size);

temp_kmem_cache_node = kmem_cache_node;
kmem_cache_node = kmem_cache_alloc(kmem_cache, GFP_NOWAIT);
memcpy(kmem_cache_node, temp_kmem_cache_node, kmem_size);




kmem_cache_create	; 새로운 kmem_cache struc 생성
kmem_cache_alloc	; slub으로부터 kmem_cache object 하나 생성

	“kmem_cache_node”
	“kmem_cache”

kmem_cache_free

o Professional Linux Kernel Architecture
	3.5.7 Allocation of Discontiguous Pages in the Kernel

o Understanding the Linux Kernel
	8.3. Noncontiguous Memory Area Management

vm_map_ram
	vb_alloc or alloc_vmap_area
	vmap_page_range
		if fail, vm_unmap_ram

vm_unmap_ram
	vb_free
		vunmap_page_range

HZ	- 1초에 발생하는 tick 수
jiffies -

sched_class : callback function (handler) interface
	kernel/sched/sched.h 에 정의

kernel/sched 아래 scheduler에 따라 각각 함수가 존재한다.
	CONFIG에 따라 특정 스케쥴러가 포함되지 않는다.
	obj-y += core.o clock.o idle_task.o fair.o rt.o stop_task.o

runqueue의 root domain
	sched_class의 관계는?


root domain




NO_HZ : 스케줄링 클럭 tick을 줄이기 위한 방법
https://www.kernel.org/doc/Documentation/timers/NO_HZ.txt

CONFIG_NO_HZ=y		; 일반적인 경우. idle CPU에서 scheduling tick의 발생을 막는다.
CONFIG_NO_HZ=n		; vexpress의 경우. scheduler tick의 발생을 막지 않는다.
CONFIG_NO_HZ_FULL	; rt의 경우 사용가능. CPU에서 idle 상태이거나 하나의 task만 실행 가능한 경우 tick의 발생을 막는다.


start_kernel의 초기…
tick_init();		; clockevent notifier를 등록한다.
boot_cpu_init();	; 부팅시 사용된 cpu를 cpu masks에 등록한다.



SCHED_SOFTIRQ
	bottom halfs의 종류 : softirq, tasklet, workqueue


CONFIG_HOTPLUG인 경우 cpuinit/cpuinitdata 등 영역에 저장됨.

	register_cpu_notifier로 등록된 notifier block을 호출하는 곳은?


fair.c

struct mm_struct
	struct vm_area_struct *mmap;
struct vmap_area
	va_start, va_end ; address 구간 정보와 rb_node, list에 등록할 수 있는 포인트를 갖고 있다.
struct vm_struct
	vmalloc, ioremap, pcpu_create_chunk 등을 통해 mapping되는 주소에 대한 구조체.
	struct page **pages와 vaddr을 멤버로 갖고 있다.

struct vm_area_struct



Documentation/filesystems/sysfs.txt
fs/sysfs/symlink.c
/sys/kernel/slab 아래 예를 들어 kmem_cache 항목을 살펴보면 됨



/* Walk a vmap address to the struct page it maps. */
struct page *vmalloc_to_page(const void *vmalloc_addr)
	; 궁금한 점은 pcpu_addr_to_page에서 이 함수를 호출한다.

pcpu_map_pages
pcpu_set_page_chunk(pages[pcpu_page_idx(cpu, i)], chunk)

첫번째 chunk인 경우 고정된 주소 공간에 만들어 지지만, 다른 chunk들은 동적으로 생성된다.
mapping 되는 page의 index에 해당하는 chunk 구조체의 주소를 적어준다.

__pcpu_ptr_to_addr(ptr) <- 이해가 필요하다.


slub의 slowpath (alloc, free 모두)를 공부하자.
pcpu_create_chunk 분석.
	1. chunk 구조체를 할당 받고 초기화
	2. chunk가 사용할 data 공간을 할당 받음 (vm_struct)
	3. chunk의 주소


pcpu ptr을 해제할 때는 map 정보만 update 되고,
실제 메모리 회수인 pcpu_recliam은 workqueue에 등록되어 호출된다.

free_partial 분석 필요

slow-path
	kmem_cache_alloc 등 -> slab_alloc -> __slab_alloc
	kmem_cache_free 등 -> slab_free -> __slab_free

free_slab -> __free_slab


RCU
rcutree.c:call_rcu_sched (= call_rcu)


주소 변환

clockevents and dynticks
http://lwn.net/Articles/223185/
	CONFIG_NO_HZ_FULL


page frame에 대한 관리
	- bootmem allocator
	- buddy allocator
	- slab allocator (policy : slub)
	- 

kmem_cache_alloc
kmalloc/kzalloc

try_to_free_pages
	/* direct reclaim에 해당하는 부분 */
	do_try_to_free_pages
		shrink_zones
			shrink_zone
				shrink_lruvec
					shrink_list
						shrink_active_list

						; 최대 nr_to_scan만큼 isolate 했다가 적당한 lru로 다시 putback.
						shrink_inactvie_list
							shrink_page_list


wait queue 이용
prepare_to_wait()
io_schedule_timeout() or something
finish_wait()

wait_on_page_bit 분석해야 함
page_referenced 추후분석


lru list - active/inactive (eviction 가능한 page들을 등록한 list)

shrink_active_list

shrink_inactive_list


KSM: Kernel Samepage Merging


page_lock_anon_vma가 복잡한 이유…?
anon_vma_free에서 anon_vma_lock, anon_vma_unlock을 호출하는 이유는?

* rmap : reverse mapping (Professional Linux Kernel Architecture 4.8)
	mm/rmap.c - physical to virtual reverse mappings

page table : virtual -> physical

특정 page를 참고하는 모든 프로세스의 페이지 테이블 엔트리 정보에 대한 자료구조.
swap-out될 때 해당 페이지를 참고하는 페이지 테이블에 기록되어야 한다.

1. When a page is ‘mapped’,
   it is associated with a process but ‘need not necessarily be in active use’.

2. The number of ‘references to a page’ indicates how actively the page is used.
   In order to determine this number, the kernel must first establish a link
   between a page and all its users and must then resort to a few tricks to find
   out how actively the page is used.


struct page {
	…
	atomic_t _mapcount;
	…
};

_mapcount는 page를 공유하는 point가 얼마나 되는지를 나타낸다.
최초값 -1을 가지며, reverse mapping 자료구조에 추가되면서 0이 되고, 추가로 mapping될 때마다 1씩 증가한다.


try_to_unmap ; page가 mapping된 모든 process의 pagetable에서 page를 unmap 한다.
	try_to_unmap_anon
		try_to_unmap_one
	try_to_unmap_file
		try_to_unmap_one
	


__do_page_fault
	handle_mm_fault
		handle_pte_fault
			pte_mkyoung


* page flags
	pageflags로 살펴본… http://studyfoss.egloos.com/5512112
	Professional Linux kernel	chap.3 하단 페이지 번호로 152.

The Page Frame Reclaimation Algorithm (PFRA)

RSS : anon + file 으로 사용 중인 page 수

Q. 여러 process에 의해 공유되는 메모리도 swap의 대상이 되는 것인가?

Q. anon_vma? 생성해서 넣어주는 부분은?

	The anon_vma element serves as a pointer to the management structure that is associated with
	each list and comprises a list head and an associated lock.

anon_vma_chain에 등록하는 과정을 살펴봐야 한다. (현재까지 루틴에서는 나오지 않았음)
	anon_vma_init은 추후 등장.

dup_mm
	dup_mmap
		anon_vma_fork
			anon_vma = anon_vma_alloc();
			avc = anon_vma_chain_alloc(GFP_KERNEL);
			anon_vma->root = pvma->anon_vma->root;
			get_anon_vma(anon_vma->root);
			anon_vma_chain_link(vma, avc, anon_vma);

anon_vma_chain_link
	list_add(&avc->same_vma, &vma->anon_vma_chain);
	list_add_tail(&avc->same_anon_vma, &anon_vma->head);




Understanding the Linux Kernel
	ch17.2.1 Reverse Mapping for Anonymous Pages
Professional Linux Kernel Architecture
	ch16. Page and Buffer Cache

swap 관련 내용 (ULK 17.4.6  The Swap Cache)
	mm/swap_state.c
	struct address_space swapper_space;



try_to_unmap_file의 경우
	prio_tree_iter를 순회한다.
	Priority Search Tree (PST)

try_to_free_swap

try_to_rlease_page
	if   mapping->a_ops->releasepage
	else try_to_free_buffers
		drop_buffers

Q. is_page_cache_freeable의 의미는?
Q. page flag 중 swapbacked?

UTLK ch15. Page Caches 봐야함 (address_space 포함)
	radix tree
writeback 봐야함.

filemap이란?
pagemap? https://www.kernel.org/doc/Documentation/vm/pagemap.txt



try_to_unuse
	swap_writepage

PageAnon
	page->mapping & PAGE_MAPPING_ANON	; user VMA에 mapping 되었을 때

IPI message

송신부


smp_call_function_single
	- 목적지 cpu가 현재 cpu라면 인터럽트를 막은 상태에서 바로 실행

	- 그렇지 않다면 generic_exec_single를 통해 IPI_CALL_FUNC_SINGLE을 날린다.

enum ipi_msg_type {
    IPI_TIMER = 2,
    IPI_RESCHEDULE,
    IPI_CALL_FUNC,
    IPI_CALL_FUNC_SINGLE,
    IPI_CPU_STOP,
};


수신부
handle_IPI

	case IPI_CALL_FUNC:
		irq_enter();
		generic_smp_call_function_interrupt();
		irq_exit();

	case IPI_CALL_FUNC_SINGLE:
		irq_enter();
		generic_smp_call_function_single_interrupt();
		irq_exit();




/* kernel/rcu.h 분석해야 함 */
struct rcu_dynticks

set_task_cpu

rcutree.c
	rcu_irq_enter
	rcu_irq_leave




/* vexpress의 경우 ct_ca9x4_init_cpu_map 에서 gic_raise_softirq 등록 */
smp_cross_call(&mask, IPI_CPU_STOP);

_mod_timer, lock_timer_base, del_timer_sync depth가 깊어 추후 분석.
kernel/timer.c
	del_timer_sync

처음 ALLOW_WMARK_LOW 주고, get_page_from_freelist를 시도.
	get_page_from_freelist에서는 메모리를 할당할 zone을 가져올 때 dirty page가 limit에 도달한 zone에서는 시도하지 않는다.

__alloc_pages_slowpath

#define ALLOC_WMARK_MIN  : 
#define ALLOC_WMARK_LOW  :
#define ALLOC_WMARK_HIGH : 

free pages 값이 water mark 아래로 떨어지면 alloc fail.
ALLOC_HARDER : water mark 값이 더 커진다.
ALLOC_HIGH   : water mark 값이 크다.

get_mems_allowed, put_mem_allowed에서 read/write seqlock을 사용한다.

seqlock - linux/seqlock.h
read critical section  : 
write critical section : 


kmalloc
__get_pages_from_freelist


* __builtin_constant_p 는 인수가 컴파일 시 상수로 알려져 있으면 정수 1을 반환하고 그렇지 않으면 0을 반환합니다.

lib/idr.c

	objects에 integer ID를 할당하고, id로 object를 찾을 때 사용.
	kernel address space에 존재하는 timer 객체에 대해 user address space에서 접근할 때,
	id를 제공하여 객체에 접근할 수 있다.

	- idr_get_new(struct idr *idp, void *ptr, int *id)
		; assign a new ID for the pointer ptr and return it via id

	- void *idr_find(struct idr *idp, int id)
		; return the pointer corresponding to id

	- void idr_remove(struct idr *idp, int id)
		; clear the entry for id


	- sub_alloc / sub_remove

o kernel/events/core.c

	perf_event_init

		idr_init (&pmu_idr)			; pmu_idr을 초기화.

		perf_pmu_register (pmu, name, type)	; pmus에 pmu를 등록.
			idr_pre_get (&pmu_idr)		; idr_layer 구조체를 id_free에 리스트로 채워 넣는다.
			idr_get_new_above (&pmu_idr)

		pmu하나에 pmu_idr이 하나씩 생성되고, 각 event type마다 integer 값이 생성된다.


	perf_event_open					; SYSCALL로 제공. fd가 리턴되고, ioctl (perf_ioctl) 명령을 받을 수 있는 index로 사용된다.

		perf_event_alloc

			perf_init_event
				pmu = idr_find(&pmu_idr, event->attr.type)	; user에서 attr로 넘어온 pmu_idr로 mapping 했던 pmu를 받아온다.
				pmu->event_init(event);


o arch/arm/kernel/perf_event.c


	perf_cpu_context (per cpu)
		perf_event_context (ctx, *task_ctx 하나씩 존재)



o sys에 device 등록

	device_initialize
	dev_set_name
	dev_set_drvdata
	device_add

	put_device

o perf package 설치 후 명령 실행
	perf list
	sudo perf top



sub_alloc 분석 중.
	pa는 0 ~ MAX_LEVEL-1. 0은 leaf.

	pa [leaf]…[top][NULL]는 다음 순서로 채워짐.

	starting_id가 65라 가정. idp->layers는 2가 된다.
	id => 65
	p => top
	l => layers - 1 = 1

	n = (id >> (IDR_BITS*l)) & IDR_MASK;	// 2 (0~31, 32~63)
	bm = ~p->bitmap;			// | | | | | … | | | n을 제외한 모두 1이라 가정.
	m = find_next_bit(&bm, IDR_SIZE, n);	// n:2, m:3

	if (m != n) {
		sh = IDR_BITS*l;		// sh:5
		id = ((id >> sh) ^ n ^ m) << sh; // (2 ^ 2 ^ 3) << 5 = 3 * 32 = 96
	}

sub_remove 분석 중.
	최대 bit shift 값과 삭제할 id로 호출된다.
	p  [*] ———> idp->top
	paa [*]———> [**]     // pa의 layer당 path 상의 각 node를 가리킴.
	pa [NULL][&idp->top][삭제할 id가 속한 하위 layer 위치][**][**][**][**]

	예) 삭제할 id: 65, shift: 5

perf_pmu_register

register_cpu_notifier

blocking_notifier_chain_register

struct swevent_htable
	struct swevent_hlist

kernel/event.core.c

note quiescent state
note_new_gpnum

다른 grace period

rcu_assign_pointer


	rcu_start_gp_per_cpu

rcu_preempt_boost_start_gp



softirq handler, rcu_kthread
	rcu_process_callbacks	/* Do RCU core processing for the current CPU. */
		for_each_rcu_flavor(rsp)
			__rcu_process_callbacks
				rcu_process_gp_end
					__rcu_process_gp_end
				rcu_check_quiescent_state
				if (cpu_has_callbacks_ready_to_invoke(rdp))
					invoke_rcu_callbacks(rsp, rdp);

invoke_rcu_core
	raise_softirq(RCU_SOFTIRQ);



CONFIG_RCU_BOOST일 경우에만 early_initcall(rcu_spawn_kthreads)로 호출.
rcu_spawn_kthreads
	kthread_run(rcu_kthread, “rcu_kthread”);




synchronize_rcu() : wait until a grace period has elapsed.
	PREEMPTIVE : 
	non-PREEMPTIVE : 
call_rcu() : callback form of synchronize_rcu()


rcu_start_gp 호출 시점
	1. rcu_report_qs_rsp

	2. force_quiescent_state

	3. rcu_prepare_for_idle

	4. call_rcu_sched, call_rcu_bh
	   call_rcu, kfree_call_rcu

		__call_rcu
			__call_rcu_core 여기


rcu_process_gp_end : 현재 gp가 끝났을 때 이 cpu에 대한 callback을 진행해 gp가 끝났음을 표시한다.
rcu_process_gp_end 호출 시점
	rcu_process_callbacks <- 호출은 rcu_kthread
	open_softirq에 대한 callback. RCU_SOFTIRQ에 의한 callback.



모든 cpu가 qs state에 들어갔다면 end_gp

1. idle에 들어갈 때
2. 이미 idle 상태일 때

context switch이 발생하면 synchronize_rcu가 끝났다고 하는 것인지?


open_softirq(RCU_SOFTIRQ, rcu_process_callbacks);
raise_softirq(RCU_SOFTIRQ)가 불리는 시점
	- invoke_rcu_core 호출 시점
		rcu_do_batch
		rcu_check_callbacks
		__call_rcu_core
		rcu_prepare_for_idle


completed gpnum
	gpnum은 gp가 시작되면 ++로 증가되어 부여된다.

gp 시작

barrios 문서에서는 아래와 같이 설명하는데, PREEMPTION RCU일 경우 
	“이렇게 시스템의 모든 CPU에서 context switch를 하는 것은 이전에 모든 RCU read-side critical sections들이 모두 일을 끝마쳤다는 것을 의미하게 되는 것이다.”


synchronize_rcu
	synchronize_sched
		if (rcu_blocking_is_gp())
			return;
		wait_rcu_gp(call_rcu_sched);

rdp 구조체
	struct rcu_head *nxtlist;
	struct rcu_head **nxttail[RCU_NEXT_SIZE];

	rcu_head은 single list로 쭉 연결되어 있고,
		[next [*], func [*]]
	nxttail은 batch 단위로 갱신시켜주기 위해 rcu_head의 next를 가리키는 포인터들이다.

rcu_head를 지니는 구조체 (struct rcu_head를 포함하는 객체들)
	nxplist ~ nxttail[RCU_DONE_TAIL]   ; done

rcu_do_batch /* callback 함수 처리 */
	rdp->qlen_lazy -= count_lazy; /* # of lazy queued callbacks */

__schedule
	/*
	 * Note a context switch.  This is a quiescent state for RCU-sched,
	 * and requires special handling for preemptible RCU.
	 * The caller must have disabled preemption.
	 */
	rcu_note_context_switch
		rcu_sched_qs			// sched 동작에 의한 qs를 기록한다.
		rcu_preempt_note_context_switch	// 이해???


rcu_check_callbacks
	rcu_sched_qs
	rcu_bh_qs

__rcu_pending
	check_cpu_stall
	…




kfree_cru
	__kfree_rcu
		kfree_call_rcu
			if CONFIG_PREEMPT_RCU
				__call_rcu(…, rcu_preempt_state, 1)
			else
				__call_rcu(…, rcu_sched_state, 1)

call_rcu
	if CONFIG_PREEMPT_RCU
		__call_rcu(…, &rcu_preempt_state, 0)
	else
		call_rcu = call_rcu_sched
		__call_rcu(…, &rcu_sched_state, 0)

__schedule


handle_IPI
	case IPI_TIMER:
		irq_enter();
		ipi_timer();
			evt->event_handler(evt);
		irq_exit();
		break;		


tick_setup_periodic(newdev, 0);
	tick_set_periodic_handler(dev, broadcast); // broadcast = 0
		if (!broadcast)
			dev->event_handler = tick_handle_periodic;


sp804_timer_interrupt			// trace에서 실제 호출된 부분
	evt->event_handler(evt);



call_rcu (= call_rcu_sched)

모든 cpu에서 qs가 발생한 뒤에, rcu_report_qs_rsp까지 탄다.
이후 대기 중인 callback을 호출하는 부분은?
	rcu_do_batch

rcu_process_callbacks	// 호출하는 곳 1. RCU_SOFTIRQ handler 2. rcu_kthread
			// 1. RCU_SOFTIRQ를 raise 하는 곳 : invoke_rcu_core
			// 



/* check하는 부분 */
// jiffies가 timer interrupt에 의해 update 되는 부분
tick_handle_periodic	/* tick_setup_periodic, */
	tick_periodic
		if (tick_do_timer_cpu == cpu) {
			do_timer(1)
				jiffies_64 += ticks;	// ticks = 1.
		}

		update_process_times
			…
			rcu_check_callbacks(cpu, user_tick);		// Check to see if this CPU is in a non-context-switch quiescent state
				if (rcu_pending(cpu))
					invoke_rcu_core();



* softirq handler, rcu_kthread
	rcu_process_callbacks	/* Do RCU core processing for the current CPU. */
		for_each_rcu_flavor(rsp)
			__rcu_process_callbacks
				rcu_process_gp_end
					__rcu_process_gp_end
				rcu_check_quiescent_state

rcu_check_quiescent_state -> rcu_report_qs_rdp -> rcu_report_qs_rnp -> rcu_report_qs_rsp


rcu_check_quiescent_state
	…
	if (!rdp->passed_quiesce)
		return;

	rcu_report_qs_rdp(rdp->cpu, rsp, rdp, rdp->passed_quiesce_gpnum);



rcu_report_qs_rsp
	rsp->completed = rsp->gpnum;
	rsp->fqs_state = RCU_GP_IDLE;





* read-side critical section
	“rcu_read_lock과 rcu_read_unlock의 사이에서는 절대 block하거나 sleep해서는 안된다는 semantics가 있다고 이전에 언급하였다.
	 그러므로 CPU가 context switch를 수행하게 되면 이전에 그 CPU에서 수행되었던 모든 RCU read-side critical section period는
	 완전히 끝났다는 것을 보장할 수 있 게 된다. 이러한 규칙을 모든 CPU에 대해 적용하면, 즉 모든 CPU가 한번씩 context switching을 하는 것을…” - barrios문서

	rcu_read_lock	// CONFIG_PREEMPT_RCU가 아닐 경우 preempt_disable로 처리.
	{ critical section }
	rcu_read_unlock

	schedule() 함수는 preempt disabled 상태에서 호출되지 않는다. (선점이 발생하는 시점은 irq, syscall 종료시점이다)
		- user, idle 상태인 경우 QS라고 할 수 있는 근거.
	역으로 context_switch가 발생했다면 rcu read-side critical section이 아니라는 것이고, QS라고 note 한다.
	따라서 schedule() 함수가 호출되면 rcu_note_context_switch()를 호출하고, rcu_sched_qs()에서 passed_quiesce로 처리한다.

	timer interrupt

A. irq 복귀시점
B. syscall 등 이후 ret_to_user

GICv2 Spec. v2.0
	* Distributor
	* CPU interface

	ID0  -     15 : SGI (Software-generated interrupt)

	ID16 -     31 : PPI (Private Peripheral Interrupt)
		This is a peripheral interrupt that the Distributor can route to any of a specified combination of processors.
	ID32 - ID1019 : SPI (Shared Peripheral Interrupt)
		This is a peripheral interrupt that is specific to a single processor.


kernel/irq/irqdomain.c : irq_domain이 무엇인가?
kernel/irq/chip.c

[from] https://www.kernel.org/doc/Documentation/IRQ-domain.txt

irq_domain interrupt number mapping library

Linux kernel의 디자인은 하나의 큰 번호 공간을 사용해 IRQ source마다 다른 번호를 나눠서 쓰고 있다.
interrupt controller가 하나일 때는 단순하지만, 여러 개의 interrupt controller가 사용될 때,
커널은 Linux IRQ 번호가 겹치지 않도록 번호를 제공해야 한다.

많은 interrupt controller가 유일한 irqchips로 등록되고, 증가하는 추세를 보여준다 :
예를 들면 GPIO 컨트롤러처럼 다른 종류의 서브드라이버들은 독립적인 CB 매커니즘을 재구현하지 않고,
irqchips로 모델링 하여 IRQ 코어시스템을 사용한다.

…


irq_desc : irq에 대한 descriptor
irq_chip : hardware interrupt chip descriptor
irq_data : irq마다 irq_chip, irq_domain 관련된 정보를 보유한다.

kernel
* request api
	request_irq
		=> request_threaded_irq
	request_any_context_irq
	request_percpu_irq		


wfi
wfe <-> sev
	ex) spin_lock

IPI
	handle_IPI : handler
	smp_cross_call : caller, GIC는 gic_raise_softirq


/* tick notifier 등록 */
tick_init
	clockevents_register_notifier(&tick_notifier);

/* tick notify */
clockevents_config_and_register
	clockevents_register_device
		clockevents_do_notify
			raw_notifier_call_chain()
// 호출하는 곳 : v2m_timer_init, percpu_timer_setup(smp_prepare_cpus 또는 secondary_start_kernel에서 호출)

clockevents_register_device
	clockevents_do_notify(CLOCK_EVT_NOTIFY_ADD, dev);


/* notify handler 동작 */
tick_notify
	case CLOCK_EVT_NOTIFY_ADD:
		tick_check_new_device	/* percpu_timer_setup -> twd_timer_setup core마다 한 번씩 호출 */
			tick_setup_device
				if (td->mode == TICKDEV_MODE_PERIODIC)
					tick_setup_periodic(newdev, 0);







ddd로 확인한 결과 twd에서 tick_periodic

__setup_irq(irqaction을 등록하는 함수)를 호출하는 곳
	setup_irq, setup_percpu_irq, request_threaded_irq, request_percpu_irq
	setup류는 Used to statically setup interrupts in the early boot process.

/* kernel/softirq.c */

/*
 * preempt_count and SOFTIRQ_OFFSET usage:
 * - preempt_count is changed by SOFTIRQ_OFFSET on entering or leaving
 *   softirq processing.
 * - preempt_count is changed by SOFTIRQ_DISABLE_OFFSET (= 2 * SOFTIRQ_OFFSET)
 *   on local_bh_disable or local_bh_enable.
 * This lets us distinguish between whether we are currently processing
 * softirq and whether we just have bh disabled.
 */



/* include/linux/hardirq.h */

thread_info의 preempt_count를 쪼개 사용한다.
#define preempt_count() (current_thread_info()->preempt_count)


#define hardirq_count() (preempt_count() & HARDIRQ_MASK
#define softirq_count() (preempt_count() & SOFTIRQ_MASK)
#define irq_count() (preempt_count() & (HARDIRQ_MASK | SOFTIRQ_MASK | NMI_MASK))

#define in_interrupt()      (irq_count())		// HARDIRQ, SOFTIRQ 포함.

IPI 핸들러에서
irq_enter
irq_exit

preempt_count의 하위 8비트만 선점 count를 기록할 때 사용된다.
위쪽은 softirq, hardirq, nmi 등의 용도로 사용된다.
특히 0x40000000은 PREEMPT_ACTIVE로 현재 thread가 선점되었음을 표시한다.

__schedule() 분석필요.
svc_preempt ; entry-armv.S
	preempt_schedule_irq

set_tsk_need_resched
preempt_check_resched



#define softirq_count() (preempt_count() & SOFTIRQ_MASK)
#define in_serving_softirq()    (softirq_count() & SOFTIRQ_OFFSET)

       CPU0       CPU1       CPU2       CPU3       

gic_notifier


IPI_RESCHEDULE 사용 예
	load_balance()
		resched_cpu(env.dst_cpu);
			resched_task(cpu_curr(cpu));
				smp_send_reschedule(cpu);
					smp_cross_call(cpumask_of(cpu), IPI_RESCHEDULE);


IPI_CALL_FUNC_SINGLE 사용예
	flush_tlb_page()
		smp_call_function_many
			smp_call_function_single
				generic_exec_single	// 다른 cpu인 경우
					IPI_CALL_FUNC_SINGLE

clockevent_config_and_register



start_kernel
—————————
prio_tree_init() : prio tree를 초기화 한다.
	http://studyfoss.egloos.com/5194196
	http://studyfoss.egloos.com/5194452
	http://studyfoss.egloos.com/5199543

init_timers() : notify를 주어 tvec_base를 초기화.

softirq_init()
timekeeping_init() : timekeeper 관련 변수 초기화.
time_init() : system_timer 설정. v2m_timer.init = v2m_timer_init
	static struct sys_timer v2m_timer = {
	    .init   = v2m_timer_init,
	};

The softirq and tasklet are both kind of bottom-halves mechanism. Sleep is not allowed because they run under interrupt context not process context.
	
Whenever a system call is about to return to userspace, or a hardware interrupt handler exits, any ‘software interrupts’ which are marked pending
 (usually by hardware interrupts) are run (kernel/softirq.c).


softirq와 tasklet 관련 소스는 sortirq.c에 같이 존재.
/sys/devices/system/cpu/cpu0 online에 0을 지정하면 drivers/base/cpu.c의 store_online 함수가 실행된다.
‘0’이 들어오면 cpu_down
		__cpu_die

	cpu_idle
		cpu_die
			platform_cpu_die
				platform_do_lowpower
					wfi();
				“b   secondary_start_kernel" // wfi에서 깨어난 뒤


‘1’이 들어오면 cpu_up


vector_irq
	// svc로 전환
	// exception 발생 당시의 mode에 따라 호출할 routine을 찾음.
	//   svc일 경우 __irq_svc

__irq_svc:
	svc_entry
	irq_handler	// gic_handle_irq -> handle_IRQ -> irq_enter, generic_handle_irq, irq_exit
	svc_exit	// svc에서 복귀하여 exception code로 진입하는 매크로


__do_softirq
	irq enable 상태에서 softirq action을 실행한다.

interrupt_context
process_context

kernel은 hardirq, softirq 모두 in_interrupt()가 참으로, interrupt context라 간주한다.

nest 횟수만큼 벗어나야 idle로 진입

rcu_idle_enter
	
rcu_idle_exit



NO_HZ & SMP
	RCU_FAST_NO_HZ

* top-half / bottom-half
	: bottom half 실행시에는 모든 인터럽트가 enable된 상태이다.
	  보통 top-half에서 device-specific 버퍼에 디바이스 데이터를 저장하고, bottom-hal에서 실행될 수 있도록 스케쥴 한 뒤 종료한다.

  top-half에 등록 - request_irq()

  tasklet 초기화 - tasklet_init()
  tasklet 예약 - tasklet_schedule()


* softirq와 tasklet
	: kernel 2.3부터 추가되어 BH를 대체한 bottom-halfs.
softirq - compile 시에 정적으로 정의되며, 같은 타입의 softirq가 동시에 여러 프로세서에서 실행될 수 있다. 네트워킹과 같이 속도에 민감한 작업은 softirq로 실행한다.
tasket - softirq를 기반으로 동적으로 정의되며, 같은 타입의 tasklet은 동시에 여러 프로세서에서 실행될 수 없다. 따라서 속도를 희생하는대신, 사용 편의성을 제공한다. 대체로 tasklet이면 충분하다.

__do_softirq에서 함수를 실행 할 때, local_irq_enable() 후 실행한다.



rcu_check_callbacks   : update_rocess_times에서 호출 <- tick handler
rcu_process_callbacks : rcu_kthread에서 호출


run_timer_softirq
	hrtimer_run_pending
	if (jiffies < timer_jiffies)
		__run_timers()


* kernel/time/Kconfig
	: hrtimer, NO_HZ(dynticks)는 oneshot 방식으로 동작한다.
	  vexpress는 정의되어 있지 않지만, exynos의 경우 아래 두 config가 포함되어 있다.

HIGH_RES_TIMERS
	select TICK_ONESHOT

NO_HZ
	select TICK_ONESHOT

rcu_start_gp
	하나의 gp를 마친 뒤 호출될 수도 있고, removal phase 이후 시작될 수 있다.
	다음 gp를 detect하기 위한 준비과정으로 hierarchy를 재초기화 한다.

synchronize_rcu
	1) PREEMPT_RCU인 경우
	wait_rcu_gp
	2) PREEMPT_RCU가 아닌 경우
	synchronized_sched


cpu_notify
clockevents_notify



void wake_up_new_task(struct task_struct *p)
	set_task_cpu(p, select_task_rq(p, SD_BALANCE_FORK, 0));

.select_task_rq     = select_task_rq_fair,

Professional Linux Kernel Architecture
	15.2.4 Dynamic Timers

The kernel needs data structures to manage all timers registered in the system.
검사는 timer interrupt마다 매번 수행해야 한다.


tick_nohz_stop_sched_tick
	get_next_timer_interrupt : analyzes the timer wheel and discovers
				   the jiffy value at which the next event is due. 

tick_do_update_jiffies64

do_timer(ticks) {
	jiffies_64 += ticks;
	…
	http://www.hanbit.co.kr/network/view.html?bi_id=1443
}


struct timekeeper - clocksource


high-res timer & dynticks
http://studyfoss.egloos.com/viewer/5268468
	clocksource : 시간 정보를 읽어오기 위한 객체(장치)이다.
	clock_event_device : 특정 시간에 이벤트(인터럽트)를 발생시키는 장치이다.
- clock event는 주기적 동작여부에 따라
	CLOCK_EVT_FEAT_PERIODIC
	CLOCK_EVT_FEAT_ONESHOT   ; hrtimer, dynticks에서 사용하는 방식.


Professional Linux Kernel Architecture. Ch.15
	CLOCK_MONOTONIC : system이 부팅된 이후 0부터 시작
	CLOCK_REALTIME  : system의 실제 시간

https://www.kernel.org/doc/Documentation/timers/highres.txt
High resolution timers and dynamic ticks design notes

* kernel/irq/manage.c의 request_percpu_irq 분석해야 함.
	arch/arm/mach-vexpress/ct-ca9x4.c twd_init 부분 함께 볼 것.


http://stackoverflow.com/questions/3523442/difference-between-clock-realtime-and-clock-monotonic
==================================================================================================================
CLOCK_REALTIME represents the machine's best-guess as to the current wall-clock, time-of-day time.
As Ignacio and MarkR say, this means that CLOCK_REALTIME can jump forwards and backwards as the system
time-of-day clock is changed, including by NTP.

CLOCK_MONOTONIC represents the absolute elapsed wall-clock time since some arbitrary, fixed point in the past.
It isn't affected by changes in the system time-of-day clock.

If you want to compute the elapsed time between two events observed on the one machine without an intervening reboot,
CLOCK_MONOTONIC is the best option.
==================================================================================================================


hrtimer.c는 항상 포함.
	CONFIG_NO_HZ, CONFIG_HIGH_RES_TIMERS일 경우 CONFIG_TICK_ONESHOT

현재 분석 흐름
tick_nohz_idle_enter
	__tick_nohz_idle_enter
		tick_nohz_stop_sched_tick
			…
			get_next_timer_interrupt


for_each_domain의 주석에 나와 있는 RCU’s qs transition의 의미는?
http://sunjinyang.wordpress.com/2010/10/06/linux-kernel-scheduling-domains-and-classes/


Greedy hrtimer expiration
http://lwn.net/Articles/461592/

_softexpires (soft) : timer의 가장 빠른 만료시간.
node.expires(hard) : _softexpires + slack(또는 delta로 지정된 값)

kernel/time/Kconfig
	TICK_ONESHOT

	NO_HZ
		select TICK_ONESHOT
	HIGH_RES_TIMERS
		select TICK_ONESHOT




tick_check_new_device
	tick_setup_device
		tick_next_period = ktime_get();	// 초기화 되는 부분




* init_timers
	timer_cpu_notify(&timers_nb, (unsigned long)CPU_UP_PREPARE, (void *)(long)smp_processor_id());
	register_cpu_notifier(&timers_nb);
	open_softirq(TIMER_SOFTIRQ, run_timer_softirq);

* hrtimers_init
	hrtimer_cpu_notify(&hrtimers_nb, (unsigned long)CPU_UP_PREPARE, (void *)(long)smp_processor_id());
	register_cpu_notifier(&hrtimers_nb);
	open_softirq(HRTIMER_SOFTIRQ, run_hrtimer_softirq);



run_timer_softirq
	hrtimer_run_pending();
	if (time_after_eq(jiffies, base->timer_jiffies))
		__run_timers(base);

hrtimer_run_pending
	if (tick_check_oneshot_change(!hrtimer_is_hres_enabled()))
		hrtimer_switch_to_hres();

hrtimer_switch_to_hres
	if (tick_init_highres()) {…}
		tick_switch_to_oneshot(hrtimer_interrupt)

	tick_setup_sched_timer	// tick emulation timer를 설정한다.
		struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
		hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
		ts->sched_timer.function = tick_sched_timer;				// hrtimer CB function 지정
		hrtimer_set_expires(&ts->sched_timer, tick_init_jiffy_update());	// expires 설정

		hrtimer_start_expires
			hrtimer_start_range_ns
				__hrtimer_start_range_ns
					switch_hrtimer_base : if necessary
					hrtimer_set_expires_range_ns
					timer_stats_hrtimer_set_start_info
					enqueue_hrtimer
					hrtimer_enqueue_reprogram

tick_sched_timer	/* CONFIG_HIGH_RES_TIMERS */	
	if (tick_do_timer_cpu == cpu)
		tick_do_update_jiffies64
			do_timer(++ticks)


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

clockevents_config_and_register
	clockevents_config(dev, freq);
	clockevents_register_device(dev);
		clockevents_do_notify(CLOCK_EVT_NOTIFY_ADD, dev);
		clockevents_notify_released();

tick_notify
	case CLOCK_EVT_NOTIFY_ADD:
		tick_check_new_device // 이전 디바이스(clock_event_device)를 해제하고, 새로운 디바이스를 등록한다.





ktime_get() : ktime_t (ns resolution)을 받아온다. wall_to_monotonic

timerqueue : expires 기준으로 rb_tree로 구성되어 있다.

struct hrtimer_cpu_base - the per cpu clock bases

	hrtimer_bases라는 변수명으로 percpu별 자료구조를 가진다.
	    DEFINE_PER_CPU(struct hrtimer_cpu_base, hrtimer_bases)
	이 percpu 구조체를 선언부에 hrtimer_clock_base 라는 구조체 배열이 선언되어 있다.

	hrtimer_cpu_base
	++++++++++++++++++++++++++++++++
	+ lock                     <—— + - lock protecting the base and associated clock bases and timers
	+ active_bases                 +
	+ …                            +
	+   +——————————————————+   <—— + — struct hrtimer_clock_base [HRTIMER_MAX_CLOCK_BASES]
	+   +     MONOTOMIC    +       +
	+   +——————————————————+       +
	+   +     REALTIME     +       +
	+   +——————————————————+       +
	+   +     BOOTTIME     +       +
	+   +——————————————————+       +
	++++++++++++++++++++++++++++++++

	hrtimer_cpu_base		// cpu개수만큼 반복
	++++++++++++++++++++++++++++++++
	…



hrtimer_clock_base - the timer base for a specific clock


Q. raise_softirq_irqoff 할 때 ksoftirqd가 자고 있을 때는 pending시키고 깨우는데, 깨어 있을 때는?
	한 번 훑고 지나간 다음 다시 돌린다.




tick_setup_periodic
	tick_set_periodic_handler(dev, broadcast);

tick_handle_periodic
	tick_periodic
		if (tick_do_timer_cpu == cpu) {
			do_timer(1)

* putback_lru_page 호출하는 곳
	putback_lru_pages
	shrink_page_list
	putback_inactive_pages
	shrink_active_list
	
*
arm_dma_alloc
	dma_alloc_from_coherent
	__dma_alloc
		__alloc_from_contiguous
			dma_alloc_from_contiguous
				alloc_contig_range
					__alloc_contig_migrate_range
						putback_lru_pages


http://linux-mm.org/PageReplacementDesign
http://studyfoss.egloos.com/viewer/5512112

* tick_periodic : tick_next_period는 초기값 0부터 tick_period만큼 누적시킨 값. 처음 tick_setup_device 호출되었을 때.
	if (tick_do_timer_cpu == TICK_DO_TIMER_BOOT) {
		tick_next_period = ktime_add(tick_next_period, tick_period);

* tick_init_jiffy_update : last_jiffies_update의 초기값은 tick_next_period
	last_jiffies_update = tick_next_period;



timekeeping_init();	// timekeeper init
time_init();		// v2m_timer_init


tick_setup_device
	tick_device_uses_broadcast



분석…
hrtimer_switch_to_hres
	tick_setup_sched_timer
		hrtimer_start_expires
			hrtimer_start_range_ns

NO_HZ => tick이 항상 periodic하게 발생하지 않는다.
HRTIMER => 

no_hz에서 다음 주기를 바꿔주는 부분?
no_hz인 경우라도 하는 일정 주기로 update가 되어야 한다.

oneshot

모든 core를 다 죽였는데, 그렇다면 jiffies를 마지막으로 

* cpu 하나는 남아서 jiffies를 update 한다.
core 중 하나는 idle(WFI)상태를 깨워줄 수 있어야 한다.

cpu hotplug online/offline에서 ARM은 0번은 끌 수 없다.

* cpu_idle 분석할 내용이 많다.


hrtimer_interrupt
tick_nohz_handler	; nohz timer interrupt handler for low res.


* softirq
	raise_softirq는 pending만 시켜둔다.
	__do_softirq에서 

irq_exit()
	if (!in_interrupt() && local_softirq_pending())
		invoke_softirq();


* 아래 메시지는 어디서? (arch/arm/mm/fault.c)
“Unable to handle kernel paging request at virtual address …”

PTP : The Precision Time Protocol is a protocol used to synchronize clocks throughout a computer network.

CLOCK_REALTIME : xtime에 사용. The xtime variable stores the current time and date (wallcloc k time. 1970년 이후로 몇 초 지났는지)
CLOCK_MONOTOMIC : 단조증가


* The common Clk Framework
  https://www.kernel.org/doc/Documentation/clk.txt
  http://elinux.org/images/b/b8/Elc2013_Clement.pdf


struct fixed_rate
+—————————————————————————————+
|                             |	
| struct clk_hw               |
| +————————————————————————+  |
| | struct clk *           |  |
| | struct clk_init_data * |  |
| +————————————————————————+  |
| fixed_reate                 |
|                             |
| flags                       |
+—————————————————————————————+

v2m_clk_init
	clk = clk_register_fixed_rate(..)
	clk_register_clkdev(clk, …)


drivers/clk/clkdev.c
include/linux/clk-private.h


arch/arm/common/timer-sp.c: sp804_get_clock_rate
	clk_get_sys(“sp804”, name);
arch/arm/kernel/smp_twd.c : twd_get_clock
	clk_get_sys(“smp_twd”, NULL);

v2m_clk_init
	clk_register_fixed_rate
	v2m_osc_register

clk_register_fixed_rate : clk 구조체를 생성하고 hierarchy 구성. parent가 바뀌면 그 child까지 변경된다.
clk_register_clkdev     : clk_lookup을 위한 구조체를 clk를 받아 생성하고, 전역 리스트에 등록한다.
	clk_find는 dev_id, con_id라는 문자열로 이루어진다.

Documentation/timers/timekeeping.txt

clocksource
clockevent : Clock events manages and distributes clock events and coordinates the use of clock event handling functions.
    	클럭이벤트는 클럭 이벤트를 관리하고 분배하며, 클럭 이벤트 핸들링 함수를 사용해 조정한다.
clock_event_device

sched_clock


*** Hrtimers and Beyond: Transforming the Linux Time Subsystems
https://www.kernel.org/doc/ols/2006/ols2006v1-pages-333-346.pdf

OS에서 Clock과 관련된 서비스
- time keeping
- clock synchronization
- time-of-day representation
- next event interrupt scheduling
- process and in-kernel timers
- process accounting
- process profiling

hardware device : 클럭 소스들을 공급할 수 있으며, 특성은 하드웨어마다 다르다.



*** The common clock framework

clk_get
clk_get_sys



setup_irq 중간에 나온 bus_lock?

qemu로 확인해 보면
# dmesg | grep -i clock
sched_clock: 32 bits at 24MHz, resolution 41ns, wraps every 178956ms
smp_twd: clock not found: -2
Switching to clocksource v2m-timer1		// v2m_sp804_init에서 sp804_clocksource_init으로 클럭소스 등록 (이후 jiffies도 clocksource로 등록)
rtc-pl031 mb:rtc: setting system clock to 2015-01-03 06:18:37 UTC (1420265917)

# cat /sys/devices/system/clocksource/clocksource0/current_clocksource 
v2m-timer1


* Documentation/timers/timekeeping.txt

     14 To provide timekeeping for your platform, the “clock source” provides
     15 the basic timeline, whereas “clock events” shoot interrupts on certain points
     16 on this timeline, providing facilities such as high-resolution timers.
     17 “sched_clock()” is used for scheduling and timestamping, and delay timers
     18 provide an accurate delay source using hardware counters.


* v2m clocksource 등록 : rating을 함께 전달해 높은 순서대로 리스트(clocksource_list)에 추가한다.
	clocksource_mmio_init
		clocksource_register_hz
			__clocksource_register_scale
				__clocksource_updatefreq_scale(cs, scale, freq);

				MUTEX_LOCK
				clocksource_enqueue
				clocksource_enqueue_watchdog
				clocksource_select
				MUTEX_UNLOCK

#define get_cpu()       ({ preempt_disable(); smp_processor_id(); })
#define put_cpu()       preempt_enable()


kswapd
	balance_pgdat


zone
	lruvec
		lists[NR_LRU_LISTS]		// add_page_to_lru_list. page->lru가 여기 추가될 때만 flag 속성의 PG_lru가 설정된다.

	pageset (struct per_cpu_pageset)	// __percpu
		pcp (struct per_cpu_pages)
			lists[MIGRATE_PCPTYPES]	// list의 앞은 hot, 끝은 cold. free_hot_cold_page에 의해 추가됨. order=0짜리 페이지들.



* 별도로 percpu로 존재하는 lru_add_pvecs.
  pagevec 중 lru 추가/삭제용 cache.
static DEFINE_PER_CPU(struct pagevec[NR_LRU_LISTS], lru_add_pvecs);
static DEFINE_PER_CPU(struct pagevec, lru_rotate_pvecs);
static DEFINE_PER_CPU(struct pagevec, lru_deactivate_pvecs);

	__lru_cache_add 에 의해 lru cache에 등록됨.



buffered_rmqueue
	if (order == 0)
		list = pcp->lists[migratetype];
		rmqueue_bulk (order = 0)	// pcp->lists[migratetype]에서 가져오는데, 만약 비어 있다면 buddy로부터 받아와 채워놓는다.
	else
		__rmqueue (order)
	

* percpu 변수 선언하고 추가/삭제 해보자
* waitqueue


* lruvec의 lru 리스트에 추가
lru_add_drain					// cpu의 pagevec에서 page를 비워 zone의 lruvec에 추가한다.
	lru_add_drain_cpu
		__pagevec_lru_add
			__pagevec_lru_add_fn
				add_page_to_lru_list
		activate_page_drain(cpu)	// activate 시켜 zone의 lru list에 등록한다.
			__activate_page
				add_page_to_lru_list

* task_struct와 thread_info는 1:1 관계
	task_struct 선언위치 : include/linux/sched.h
		kmem_cache_alloc으로 할당
	thread_info 선언위치 : arch/arm/include/asm/thread_info.h
		.stack을 위해 공간을 할당받고, overlay해 사용된다.

* thread_info의 cpu에 언제 현재 수행 중인 cpu번호를 넣는 것인가?
	smp_processor_id는 thread_info에서 cpu번호를 가져오는데, 여기에서 궁금증 시작

	# define smp_processor_id() raw_smp_processor_id()
	#define raw_smp_processor_id() (current_thread_info()->cpu)

	kernel/sched/sched.h에서
	set_task_cpu
	init_idle
		__set_task_cpu
			task_thread_info(p)->cpu = cpu;
* cpu의 rq에 idle task를 가리키는 포인터가 존재한다.


platform_smp_prepare_cpus
	v2m_flags_set(virt_to_phys(versatile_secondary_startup));	// 다른 코어가 깨어났을 때 수행할 코드 주소.
		// when pen released, 
		secondary_startup


start_kernel
	sched_init
		init_idle(current, smp_processor_id());
			rq->curr = rq->idle = idle;
		#ifdef CONFIG_SMP
		idle_thread_set_boot_cpu();			// percpu 변수에 넣어준 부분
		#endif
			per_cpu(idle_threads, smp_processor_id()) = current;

kernel_init
	smp_init
		idle_threads_init				// idle_threads를 초기화 한다.
			idle_init(cpu);				// boot_cpu가 아닌 것들에 대해서만.
				tsk = fork_idle(cpu);
					copy_process( …, init_struct_pid, …)	// struct 구조체 복사
					init_idle_pids(task->pids);
					init_idle(task, cpu);	// 
				per_cpu(idle_threads, cpu) = tsk; // percpu idle_threads로 tsk를 지정
		cpu_up(cpu)
			_cpu_up(cpu, tasks_frozen = 0)
				idle = idle_thread_get(cpu)	// idle_init에서 넣어둔 idle_threads를 읽어온다.
					tsk = per_cpu(idle_threads, cpu);	// idle_threads로 지정한 tsk를 받아와
					init_idle (tsk, cpu);	// 해당 cpu의 idle task로 지정한다.
						__set_task_cpu	// cpu 번호를 stack의 cpu에 넣어줌.
				__cpu_up(cpu, idle)		// secondary_data 초기화 (.stack, .pgdir, .swapper_pg_dir)
					boot_secondary(cpu, idle)	// pen_release 값을 써준다.
						write_pen_release(cpu_logical_map(cpu))
						gic_raise_softirq(cpumask_of(cpu), 0)


copy_process
	p = dup_task_struct(current);
		ti = alloc_thread_info_node(tsk, node);		// thread_info를 위한 메모리 공간이 할당된다. task_struct은 kmem_cache_alloc으로 할당받는데, 왜?
		err = arch_dup_task_struct(tsk, orig);
		tsk->stack = ti;
		setup_thread_stack(tsk, orig);
	…
	copy_thread()


* pen_release

	platsmp.c: platform_smp_prepare_cpus 에서 soft interrupt를 받으면 이 함수로 이동한다.
	versatile_secondary_startup				// pen_release에 자기 cpu가 올 때까지 대기한다.
		secondary_startup				// __secondary_data를 읽어온다.
			#PROCINFO_INITFUNC			// __v7_ca9mp_setup
			__enable_mmu				// r4 => TTBR0 ; __secondary_data.pgdir
				__turn_mmu_on
					__secondary_switched
						secondary_start_kernel
							…
							cpu_switch_mm(mm->pgd, mm);
							…
							cpu_init
							platform_secondary_init
								gic_secondary_init(0);
								write_pen_release(-1);	// pen_release를 푼다.
							…
							cpu_idle




* TLS
	멀티스레드 어플리케이션에서 동일한 메모리 공간을 공유하는 (주로 전역변수) 프로세서의 스레드들은
	때때로 스레드마다 유일한 데이터를 저장해야 할 필요가 있다. errno가 대표적인 예이다.
	Cortex-A 시리즈로 오기 전까지, ARM은 TLS를 지원하지 않았으므로 리눅스에서 에뮬레이션 해주었다.

	arch/arm/asm

* thread_info 관련 함수/매크로
	arch/arm/include/asm/thread_info.h

	current_thread_info

	thread_saved_pc(tsk)	<- stacktrace 등에서 사용
	thread_saved_sp(tsk)
	thread_saved_fp(tsk)

	unwind_backtrace로 이전 데이터의 stack 내용을 출력할 때 사용된다.
	frame.sp = thread_saved_sp(tsk);

* 현재 thread를 sp를 통해 접근해 얻어 오는 방법.
	sp가 가리키는 stack의 낮은 주소에 thread_info가 overlay 되어 있고,
	이 thread_info에서 task라는 포인터로 task_struct를 가리키고 있다.

	#define current (get_current())
	get_current
		return current_thread_info()->task;
			// current_thread_info는
			// register unsigned long sp asm ("sp");
			// return (struct thread_info *)(sp & ~(THREAD_SIZE - 1));

	문맥교환시 sp 역시 변경된다.
	__schedule
		context_switch
			switch_to
				__switch_to		// 두 task 사이의 문맥 전환 함수. register를 교환한다. sp 포함.

* arm_syscall

* ACPS
	Table 6.1. APCS registers
	Register	APCS name	APCS role
	r0	a1	argument 1/scratch register/result
	r1	a2	argument 2/scratch register/result
	r2	a3	argument 3/scratch register/result
	r3	a4	argument 4/scratch register/result
	r4	v1	register variable
	r5	v2	register variable
	r6	v3	register variable
	r7	v4	register variable
	r8	v5	register variable
	r9	sb/v6	static base/register variable
	r10	sl/v7	stack limit/stack chunk handle/register variable
	r11	fp/v8	frame pointer/register variable
	r12	ip	scratch register/new -sb in inter-link-unit calls
	r13	sp	lower end of the current stack frame
	r14	lr	link register/scratch register
	r15	pc	program counter

calibrate_delay_converge


* 한 jiffies 내에서 얼마만큼의 연산(여기서는 delay)을 처리할 수 있는지 봐야하기 때문에 다음 지피가 시작될 때까지 대기한다.
	tick = jiffies;
	while (tick == jiffies) ;
	tick = jiffies;


[1단계] trial 단위로 delay를 수행하며 tick이 변하지 않는 최대 tiral 위치를 찾아낸다.

* 밴드가 이동할 때마다 trial 수는  2배씩 증가하고, trial 내의 delay는 밴드를 따라간다.
	o  : delay 하나 (lpj 단위)
	[] : trial 하나

band
    0    1    2    3    4 ..
        [o]  [oo] [ooo]
        [o]  [oo] [ooo]
         [oo] [ooo]
         [oo] [ooo]
              [ooo]
              [ooo] <- tick이 넘어가면 밴드 내의 특정 trial까지 수행한 상태이다.
              [ooo]
              [ooo]


* 나머지 부분을 찾기 위해, 최고정밀도에 도달할 때까지 정밀도를 2배씩 높여가며 lpj에 누적시킨다.

mm_rmap

mmap_init : vm_committed_as 0으로 초기화

overcommit : Documentation/vm/overcommit-accounting
	0 - (Default) Heuristic overcommit handling.
	1 - Always overcommit.
	2 - Don't overcommit.

sector => 물리적 addressing이 가능한 최소 단위.
sector : block = 1~N : 1

block <= PAGE
block : buffer = 1 : 1

buffer head => 버퍼 디스크립터

fs/block_dev.c를 보면 두 개의 operations가 있다.


* address_space_operation : 

파일시스템마운트
https://www.linux.co.kr/home2/board/subbs/board.php?bo_table=lecture&wr_id=1644

address_space는 page cache를 구현하는, 아주 중요한 역할을 하는 구조체이다.
또한 실제로 파일시스템에서 블록을 읽기 위한 기능을 구현하는 address_space_operations 구조체를 포함하기도 한다. 

file_operations 구조체는 응용 프로그래머들이 일반적으로 사용하는 open, read, write, close, ioctl, mmap 등과 연관되는 함수이다.
일반적으로 file_operations의 함수들은 최종적으로 address_space_operations의 함수들을 호출해 실제적으로 block device에서 페이지들을 읽게 된다.


Professional Linux Kernel Architecture



config_keys, config_security
credentials


지연된 작업
	* tasklet   : 
	* workqueue : 

tasklet : softirq에 기반한 bottom half 매커니즘. include/linux/interrupt.h 참고.

	DECLARE_TASKLET()
	tasklet_handler : softirq context에서 수행되며, 휴면되지 않는다.
	tasklet_schedule : tasklet을 스케쥴(등록)하는 함수
		__tasklet_schedule
			로컬 인터럽트를 막은 상태에서 raise_softirq_irqoff로 호출.
			raise_softirq_irqoff는 해당 softirq를 pending 시키고, 인터럽트 상황이 아니라면 wakeup_softirqd를 호출한다.
		ksoftirqd는 core별로 하나씩 동작하는 thread.

	tasklet_action : tasklet softirq가 펜딩되면 호출되는 action

softirq
	* ksoftirqd는 core마다 하나씩 생성.
	* 우선순위에 따라 번호가 주어지고, tasklet도 그 중 하나.
	* 

	* invoke_softirq
		호출지점 : irq_exit

	* __do_softirq 호출위치 : do_softirq, invoke_softirq, run_ksoftirqd
		do_softirq 호출지점 : 

	__do_softirq는 __local_bh_disable을 호출한 상태에서, local interrupt를 활성화한 상태로 진행한다.


/* 이 순서가 우선순위로, __do_softirq에서 우선순위 순으로 작업을 실행한다. */
enum
{
    HI_SOFTIRQ=0,
    TIMER_SOFTIRQ,
    NET_TX_SOFTIRQ,
    NET_RX_SOFTIRQ,
    BLOCK_SOFTIRQ,
    BLOCK_IOPOLL_SOFTIRQ,
    TASKLET_SOFTIRQ,
    SCHED_SOFTIRQ,
    HRTIMER_SOFTIRQ,
    RCU_SOFTIRQ,    /* Preferable RCU should always be the last softirq */

    NR_SOFTIRQS
};

tasklet_trylock(), tasklet_unlock()
	: TASKLET_STATE_RUN을 검사한다.


tasklet_disable(), tasklet_enable()
	: count, 즉 disable count를 두고 tasklet의 실행을 막는다.


tasklet_vec은 percpu로 존재한다.



example) fs/proc/cpuinfo.c

file_operations
	.open
	.read
	.llseek
	.release

fs/seq_file.c
	seq_open
	seq_read
	seq_lseek
	seq_printf

seq_open시 seq_operations 구조체를 지정한다.
	seq_operations 를 드라이버 개발자가 구현해야 하는 operations.





GFP_ATOMIC	!(__GFP_WAIT) && (__GFP_HIGH)
	interrupt context에서 메모리 할당을 위해 사용되는 flag. ALLOC_HIGH로 할당 요청이 되고, 할당이 불가능하다 할지라도 sleep 되지 않고 바로 리턴된다.

	(__GFP_HIGH) == (ALLOC_HIGH)
	=> __zone_watermark_ok에서 watermark 기준치가 낮게 설정된다. 따라서 check를 통과할 가능성이 높아진다.





struct percpu_counter {
	raw_spinlock_t lock;
	s64 count;
	s32 __percpu *counters;
};


ida & idr
http://studyfoss.egloos.com/5187192
 : ida는 id 할당만을 받고 포인터 매핑은 하지 않는다. ida는 layr[0]의 ary에 독자적인 bitmap에 대한 포인터를 저장한다.

mnt_id를 어디서 사용하는가? fhandle

fhandle
	name대신 handle을 쓴다.
	name_to_handle_at : convert name to handle

	Open by handle
	http://lwn.net/Articles/375888/


sysfs_init부터 … depth가 깊어진다.




[address space]
	page -> 커널이 물리적 메모리를 관리하기 위해 사용하는 단위


inode <-> address_space 1:1 매핑

여기서 address_space는 


- page cache 는 struct address_space 구조체로 관리됩니다.
- 보통 inode에 들어 있는데요, i_mapping 변수 입니다.
- struct address_space 구조체의 page_tree 를 따라가시면 현재 page cache 에서 캐쉬하고 있는 각 page 를 알수 있습니다. (따라가는 부분은 linux 소스 코드를 확인해 보세요)
- 즉, struct page 구조체 정보를 알수 있는데요, struct page 구조체 정보에서 실제 물리주소 정보를 알아내실수 있을듯 합니다.

VFS
 - 커널에서 파일시스템(디렉토리 및 파일 억세스)을 다룰 때 사용되는 컴포넌트이다.
 - 많은 파일시스템의 공통 작업을 추상화해 놓은 레이어.
 - 파일 관련 시스템콜을 통해 단일 인터페이스를 유저에게 제공한다.

	내부적으로 dcache와 inode cache를 유지한다.
 : http://haifux.org/lectures/119/linux-2.4-vfs/linux-2.4-vfs.html


* page cache
 : The page cache caches pages of files to optimize file I/O.

* buffer cache
 : The buffer cache caches disk blocks to optimize block I/O.


* the superblock object
 : 마운트 된 파일 시스템에 관한 정보를 저장합니다. 디스크 기반 파일 시스템의 경우, 이 개체는 일반적으로 디스크에 저장된 파일 시스템의 제어 블록에 대응한다.

* the inode object
 : 특정 파일에 대한 일반적인 정보를 저장한다.
   디스크 기반 파일 시스템의 경우(그 외 가상 파일시스템, 네트워크 파일시스템 등), 이 개체는 일반적으로 디스크에 저장된 파일 제어 블록에 대응한다.
   각 아이노드 객체는 고유의 파일 시스템 내에서 파일을 식별하는 아이 노드 번호와 연관되어 있습니다.

   파일이 생성될 때 만들어진다. dentry와 달리 디스크에 존재한다.

* inode cache
 : cache of "inode" objects, used to represent files and directories on the file systems.

* dcache
 : cache of "dentry" objects, used to translate paths to inodes.
   해당 파일과 디렉토리 엔트리의 링크에 대한 정보를 저장 (즉, 파일의 특정 이름이다). 각각의 디스크 기반 파일 시스템에 저장 디스크에 자신의 특별한 방식으로 이 정보를 제공합니다.

   디렉토리 내의 파일 이름은 디스크에 저장되어 있지만, 성능 향상을 위해 메모리에 저장한다.

   dcache는 부모 dentry와 파일 이름을 키로 하는 hash table로 구현되어 있으며
   시스템의 가용 메모리 크기에 따라 동적으로 크기를 조정하기 위해 LRU 리스트를 별도로 유지한다.

   dcache는 이름을 통해 파일에 접근하는 (보통 path lookup 혹은 path walk라고 한다) 시스템 콜(open, access, stat, chmod, ...)의 성능에 많은 영향을 미치게 된다.


http://www.quora.com/Linux-Kernel/What-is-the-major-difference-between-the-buffer-cache-and-the-page-cache

* dentry와 inode cache 관계
* file table과 file descriptor 관계

* superblock은 type이라는 포인터로 file_system_type을 가리킨다.	
  file_system_type의 fs_supers 리스트에는 연결된 superblock 리스트를 가리킨다.

per-sb shrinker???



vfs_caches_init
	dcache_init
	inode_init
	files_init
	mnt_init
		init_rwsem
		kmem_cache_create
		__get_free_page
		sysfs_init				// 
		kobject_create_and_add
		init_rootfs
		init_mount_tree				// rootfs 마운트
	bdev_cache_init
		kmem_cache_create
		register_filesystem
		kern_mount = kern_mount_data
		blockdev_superblock = bd_mnt->mnt_sb;	// for writeback
	chrdev_init


sysfs_init
	kern_mount = kern_mount_data
		vfs_kern_mount
			mount_fs
				sysfs_mount		// struct file_system_type의 .mount 콜백 호출됨
					sget		// here
					sysfs_fill_super
					dget

alloc_super

wait_table은 zone에 포함.
bit_waitqueue는 왜 이 wait_table에 종속되게 설계 되었을까?

zone_wait_table_init
	zone의 wait_table 초기화

kernel/wait.c

io_schedule()

virt_to_page
page_zone


wait_table, wait_table_bits, and wait_table_hash_nr_entries implement a wait queue for processes waiting for a page to become available. While the details of this mechanism are shown in Chapter 14, the intuitive notion holds pretty well: Processes queue up in a line to wait for some condition. When this condition becomes true, they are notified by the kernel and can resume their work.

sysfs_mount
	sysfs_fill_super		// sget에 의해 새로 생성된 sb인 경우, sb의 정보를 채워 넣는다.
		sysfs_get_inode
			iget_locked	// ino로 inode를 찾아 오브젝트를 리턴하는데, 존재하지 않는다면 검색용으로 받은 inode 번호로 inode를 할당하고 i_state에 I_NEW를 리턴한다. 나머지 정보는 호출자가 채워야 한다.
		d_make_root		// root_inode를 받아 이 inode를 위한 dentry를 할당받고 초기화해 리턴한다.
			__d_alloc()	// 
			d_instantiate()	// __d_alloc이 성공했다면 inode 정보를 dentry에 채운다.
			



Step by Step 커널 프로그래밍 강좌⑤ 파일시스템마운트
Step by Step 커널 프로그래밍 강좌⑥ 파일시스템마운트

Professional Linux Kernel Architecture. Ch.8 VFS

/usr/bin/emacs => ‘/‘ -> ‘usr’ -> ‘bin’ -> ‘emacs’

1. root directory부터 search 시작.


struct page 의 mapping 
	file->f_dentry->d_inode->i_mapping

__LITTLE_ENDIAN <- 언제 정의되어 추가되나?

include/linux/seqlock.h의 seqcount


inode <-> dentry는 1:n 관게.
inode는 파일 하나당 하나씩 생성. dentry는 여러 경로로 inode에 연결될 수 있다.


d_make_root 분석 중


http://egloos.zum.com/studyfoss/v/5469672
Documentation/filesystems/path-lookup.txt

Dcache scalability and RCU-walk
	https://lwn.net/Articles/419811/

rcu-walk
	


* dcache는 directory-entry (= dentry)의 cache를 말하는 것이다.
* dcache는 ‘부모 dentry와 파일 이름’을 키로 하는 hash table로 구현되어 있으며
  시스템의 가용 메모리 크기에 따라 동적으로 크기를 조정하기 위해 LRU 리스트를 별도로 유지한다.

* 최종 위치까지 path lookup을 하는 과정마다 dcache에서 dentry를 찾고, 이 과정 중에 이미 찾아놓은 경로의 dentry가 해제되지 않도록 하기 위해
  각 dentry의 ref-count를 증가시키는 방법(ref-walk)을 사용했다.

  하지만 이렇게 ref-count를 증가시키는 동작이 다른 cpu의 cache를 깨먹는 등 성능에 영향을 많이 미치게 된다.
  dentry 자체를 수정하지 않고 path lookup을 수행하도록 갱신되었다.
  항상 사용할 수 있는 방법은 아니고, fast-path에만 허용된다.

  rcu-walk : path lookup시 경로의 dentry가 모두 dcache에 있다는 가정하에, 전체 단계에 rcu_read_lock/rcu_read_unlock을 둔다.
  

lookup_fast
	__d_lookup_rcu


atomic_dec_and_lock
lib/dec_and_lock.c	<- include/linux/spinlock.h

dcache table은 dcache_init_early에서 초기화 한다.
hlist_bl_head의 array 형태의 table이다. 첫번째 node는 bit lock 속성을 갖고 있고, rcu함수로 보호(include/linux/rculist_bl.h)될 수 있다.

from Docu../filesystems/vfs.txt
———————————————————————————————


system call로 전달된 파일 이름은, VFS에서 directory entry cache를 검색하는데 사용된다.
이 dcache는 빠르게 pathname(filename)을 특정 dentry로 전환시켜주는 look-up 매커니즘이다.
메모리에만 존재하는 객체로, 오직 퍼포먼스를 위해 사용된다.

pathname으로 dentry를 해석한 다음, VFS는 그 길을 따라 dentry를 만들기 위해 resort 해야 할 수도 있다.
그리고 inode를 로딩한다.





from Linux Kernel Development
——————————————————————————————


* VFS의 주요 오브젝트 타입
  - superblock : 특정 마운트된 파일시스템을 표현하는 오브젝트
  - inode : 특정 파일을 표현하는 오브젝트
  - dentry : directory entry를 표현하는 오브젝트. 한 경로에서 한 컴포넌트를 표현한다. (마운트 포인트와 최종 파일도 해당)
  - file : 어떤 프로세스와 연결되어 열린 파일을 표현하는 오브젝트

* VFS의 operations 오브젝트
  - super_operations : 커널이 특정 파일시스템에 대해 호출할 수 있는 메소드들의 오브젝트. 예) write_inode(), sync_fs()
  - inode_operations : 커널이 특정 파일에 대해 호출할 수 있는 메소드들의 오브젝트. 예) create(), link()
  - dentry_operations : 커널이 특정 디렉토리 엔트리에 대해 호출할 수 있는 메소드들의 오브젝트. 예) d_compare(), d_delete()
  - file_operations : 어떤 프로세스가 열린 파일에 대해 호출할 수 있는 메소드들의 오브젝트. 예) read(), write()

* VFS의 다른 오브젝트
  - file_system_type : 등록된 파일시스템에 대한 서술과 캐퍼블리티 정보를 나타낸다.
  - vfsmount : 마운트 위치와 마운트 플래그 등 마운트 포인트 정보를 나타낸다.
  - fs_struct, file : 프로세스와 연관된 프로세스별 구조체로 각각 파일시스템과 파일에 대한 정보를 나타낸다.

* dcache
  - dentry는 한 경로에서 각 컴포넌트마다 존재하는 자료구조이다.
    경로를 찾기 위해 매번 각 단계의 dentry를 조사해 경로를 찾는 것은 지극히 효율성이 낮다.
    따라서 커널은 dcache 상에 dentry 오브젝트들을 캐시 시킨다.
  - dcache는 세 파트로 구성된다.
    Lists of “used” dentries - inode의 i_dentry 필드에 링크. (dentry의 d_alias로 연결)
    A doubly linked “least recently used” list of unused and negative dentry objects. superblock의 s_dentry_lru에 링크. (dentry의 d_lru로 연결)
    A hash table and hashing function used to quickly resolve a given path into the associated dentry object. dentry_hashtable에 링크.
        (dentry의 d_hash로 연결)









dentry_string_cmp
	load_unaligned_zeropad


do_filep_open
	path_openat
		link_path_walk
			walk_component
				lookup_fast
					__d_lookup_rcu


up_write 분석
	include/linux/rwsem-spinlock.h



… sysfs는 ida를 언제 사용하나?

rootfs가 먼저 호출, init이 호출된 후에 busybox의 init이 rcS스크립트 실행

// busybox 생성시 사용
$ cat etc/init.d/rcS
#!/bin/sh
mount -t proc none /proc
mount -t sysfs none /sys
/sbin/mdev -s

qemu에서 initrd로 주어진 옵션에 의해 parse_tag_initrd2이 호출됨.

* img mount command
bzcat /boot/initramfs-2.6.32-279.el6.i686.img > $HOME/initramfs-2.6.32-279.el6.i686.cpio
cd $HOME
mkdir initramfs
cd initramfs
cpio -vid < ../initramfs-2.6.32-279.el6.i686.cpio


timekeeper 분석..
current_kernel_time

#define CURRENT_TIME        (current_kernel_time())
#define CURRENT_TIME_SEC    ((struct timespec) { get_seconds(), 0 })

2014.11.1, 2014.12.27 자료 참고.

struct timekeeper {
}

ktime_get
	timekeeping_get_ns


do_timer
	update_wall_time
		accumulate_nsecs_to_secs



sysfs_alloc_ino : sysfs용 ida로부터 정수값을 할당받는다.

sysfs_dirent의  s_bin_attr. 용도는?

case SYSFS_KOBJ_BIN_ATTR:
sysfs_create_bin_file


kobject 인터페이스 함수
kobject_create_and_add(name, parent)
	mnt_init()에서 kobject_create_add(“fs”, NULL);


* The Linux Device Model 공부할 것.
	kobject_uevent  - notify userspace by sending an uevent


살펴본 file_system_type. .name, .mount, .kill_sb는 정의하고 있다.
	- sysfs
	- rootfs
	- ramfs (아직 보진 않았지만 rootfs 바로 위에 있음)

* ida_remove 주석 달기

lib/parser.c : match_token, match_int

include/linux/stat.h
	S_ISUID

get_next_ino

init_cred 언제 초기화 되나?
	https://www.kernel.org/doc/Documentation/security/credentials.txt

vmscan 정리하기.

bdi_destroy 주석 달기

fs->owner 는 module *인데, 이 초기화가 어떻게 이뤄지나?

mntput 주석 달기

nsproxy - namespace



alloc_vfsmnt()는 struct mount를 생성하고 초기화 한다. struct vfsmnt가 struct mount 내에 포함되어 있기 때문이다.

// mnt_pcp는 percpu 포인터
생성: mnt->mnt_pcp = alloc_percpu(struct mnt_pcp);
접근: per_cpu_ptr(mnt->mnt_pcp, cpu)

#ifdef CONFIG_SMP
this_cpu_add(mnt->mnt_pcp->mnt_count, n);
#endif

big-reader lock. kernel에서는 lglock.c


init_mount_tree
	create_mnt_ns

	set_fs_pwd
	set_fs_root

d_make_root ; root inode를 받아 dentry를 할당받고 설정해 리턴한다.
	__d_alloc	; dentry alloc
	d_instantiate	; dentry에 inode 정보를 채워 인스턴스화 시킨다.

sysfs -> sysfs_mount
ramfs/rootfs -> ramfs_mount -> mount_nodev
bdev -> bd_mount -> pseudo_mount


flex_proportion

각 filesystem별로 독자적인 MAGIC NUMBER가 존재한다.
	VFS 공통 ops정보를 채워야 한다.

sysfs
	sysfs_mount - sysfs_fill_super

rootfs/ramfs
	rootfs_mount/ramfs_mount - mount_nodev - ramfs_fill_super

procfs
	proc_mount - proc_fill_super


XXX_fill_super류의 함수 : superblock 자체의 정보도 채우고, root inode에 해당하는 dentry를 받아와 저장한다.
	이 함수에서 mount시 제공된 옵션을 ,를 기준으로 파싱해 처리한다.

mount시 제공되는 옵션을 처리하기 위해 match_table_t를 옵션 처리 함수와 더불어 정의하고 있다.
procfs의 경우, match_table과 proc_parse_options를 정의한다.
ramfs의 경우, match_table과 ramfs_parse_options를 정의한다.



pid_namespace

struct pid {
	/* Try to keep pid_chain in the same cacheline as nr for find_vpid */
	int nr;
	struct pid_namespace *ns;
	struct hlist_node pid_chain;	// hash list로 연결하고 싶은 자료구조.
};

* hash table은 hlist_head 배열로 이루어 진다. 각 hlist_head를 연결하기 위한 hlist_node가 있는데, 이 hlist_node를 포함하는 구조체가 실제 관리하고자 하는 데이터이다.



* struct proc_dir_entry와 struct proc_inode를 설명해보자.

* struct pernet ???


#################
  pid_namespace
#################

* Professional Linux Kernel Architecture
    Figure 2-5: Overview of data structures used to implement a namespace-aware representation of IDs.
* [Linux] PID 관리
    http://studyfoss.egloos.com/5242243

/* pid_namespace는 tree 형태로 계층구조로 존재한다. 각 namespace는 몇 번째 레벨에 속하는지 level 번호가 존재한다. 관련 api들은 pid_namespace.c에 정의되어 있다. */
pidmap_init

struct pid_namespace
	struct pidmap pidmap[PIDMAP_ENTRIES];	// namespace에 속하는 pid들을 bitmap으로 관리한다. pidmap_init에서 초기화.
	struct kmem_cache *pid_cachep;
	unsigned int level;
	struct pid_namespace *parent;

struct pid_namespace init_pid_ns;




* /proc/sys ==> sysctl
  struct ctl_table         : 각 sysctl entry. sysctl table은 이 구조체의 배열로 구성된다.
  struct ctl_node          : rb_node와 ctl_table_header 포인터로 구성된다.

  struct ctl_table_header  : struct ctl_table 트리를 동적 리스트로 관리하기 위한 자료구조.
  struct ctl_dir	   : ctl_table_header와 rb root로 구성된다.
  struct ctl_table_set     : Sysctl tree	
  struct ctl_table_root    : sysctl table hierarchy의 root

  struct ctl_path          :

	register_sysctl(paht, table)로 등록하면 ctl_table_header가 리턴된다.


Professional Linux Kernel Architecture
    Ch. 10 Filesystems without Persistent Storage

* 스케쥴 : 리뷰 / 진도
	- 아키텍쳐
		arm, MMU
	- 메모리 할당/해제 (memblock, 버디, 슬랩)

	- 동기화 RCU
	- timer
	- 자료구조 (RB-Tree, radix-tree, idr/ida, hash table)
	- VFS

	- cgroup은 추후 v2로 분석.
	- 그 주 스터디할 내용 관련 chapter와 자료 정리

* 방법론
	- 함수와 API 위주의 분석

include/linux/moduleparam.h

core_param
module_param


Shareable Device
The TCM region overrides memory type attributes of the MPU and all addresses within the TCM space are treated as Normal, Non-Shared memory.

Cortex-A series PG
	* Table 9-2 Memory attributes
	  Memory Type		Shareable/Non-shareable		Cacheable

	  Normal		Shareable/Non-shareable		Yes
	  Device		-				No
	  Strongly-ordered	-				No

	* Table 9-3 Memory type and cacheable properties encoding in translation table entry

The only difference between Device and Strongly-ordered memory is that:
• A write to Strongly-ordered memory can complete only when it reaches the peripheral or memory component accessed by the write.
• A write to Device memory is permitted to complete before it reaches the peripheral or memory component accessed by the write.

System peripherals will almost always be mapped as Device memory.

Regions of Device memory type can be described using the Shareable attribute.

On some ARMv6 processors, the Shareable attribute of Device accesses is used to determine which memory interface will be used for the access,
 with memory accesses to areas marked as Device, Non-Shareable performed using a dedicated interface, the private peripheral port.
 This mechanism is not used on ARMv7 processors.



vmap : 페이지를 가상 주소로 연속적인 공간에 매핑한다. struct vm_struct, struct vm_map 자료구조. 어떤 식으로 엮고, 어떤 식으로 찾나?
get_vm_area_caller()로 vm area를 받아오고, map_vm_area()로 매핑한다.
map_vm_area는 내부에서 vmap_page_range() 호출.



sched_class

cfs schduler 분석
http://iloveriver.egloos.com/6117181

cpu_stopper thread로 실행하는 이유
	=> stop_sched_class로 실행되며, 실행되는 동안 선점불가이다.

clockevents_config_and_register


enable_percpu_irq
	irq_percpu_enable



* tick_init에서 tick_notifier로  tick_notify가 등록된다.
* clockevents_register_device : clock event device를 등록한다.
	clockevent_devices 리스트에 추가하고,
	CLOCK_EVT_NOTIFY_ADD notify를 날린다.
	위 tick_notify가 호출된다.

  broadcast_timer_setup이나 timer_init 함수 등에서 호출된다.

* 관건은 tick_notify인데, CLOCK_EVT_NOTIFY_ADD에 대해
  tick_check_new_device를 호출한다.
  등록된 device가 사용되어야 하는지 판단하는 용도로 사용된다.

  최종 판정된다면, clockevents_exchange_device(curdev, newdev);를 호출하는데, 
  현재 등록된 디바이스를 list_add(&old->list, &clockevents_released)에 등록시킨다.

* 이상한 것은 clockevents_released에 등록해 두는 것인데, 

start_kernel
	time_init
		v2m_timer_init
			v2m_sp804_init
				sp804_clockevents_init
					clockevents_config_and_register
						clockevents_register_device
							clockevents_notify_released

위 순서로 처음 v2m_timer가 등록.
다음 percpu_timer_setup에서 twd_timer_setup에 의해 “local_timer”가 4번 등록.

v2m_timer_init



include/asm-generic/vmlinux.lds.h

do_early_param
	__setup_start ~ __setup_end		// 섹션의 함수 실행		
do_pre_smp_initcalls
	__initcall_start ~ __initcall0_start	// // early_initcall

platform_smp_prepare_cpus
	v2m_flags_set(virt_to_phys(versatile_secondary_startup));	// (headsmp.S) v2m register에 secondary CPU를 위한 entry 함수를 기록한다.


identity mapping
	http://lists.kernelnewbies.org/pipermail/kernelnewbies/2012-June/005552.html
	http://www.spinics.net/lists/newbies/msg46709.html

	…
	The kernel sets up a small identity mapping (virtual == physical) as well as a the kernel direct mapping.

System.map을 보면, __idmap_text_start ~ __idmap_text_end 사이의 심볼들을 볼 수 있다.
	그 중 __turn_mmu_on이 핵심이다.



1. identity mapping이란?
	physical address == virtual address mapping
2. 왜 __turn_mmu_on이 identity mapping으로 들어가야 하나? 이미 커널 공간에 대해 복사해 두고?
	커널 공간은 p <-> v 간 1:1 매핑이 아니다.
3. identity mapping을 할 경우 기존 kernel mapping 된 영역이 덮여 쓰일 가능성이 있지 않나?
  그렇다면 page table을 변경하기 전까지 실행되는 코드 주소가 override 되지 않을까?
	

secondary_start_kernel
	cpu_switch_mm(mm->pgd, mm); 	// mm은 init_mm이고, page table을 switch 한다. (= cpu_v7_switch_mm)
		// TTB0의 레지스터를 설정한다.



arm kernel 에서 task_struct, thread_info, switch_to 그리고 stack
http://forum.falinux.com/zbxe/index.php?mid=lecture_tip&listStyle=list&page=10&document_srl=808363

kthread_bind


update_process_times
	run_local_timers();
		raise_softirq(TIMER_SOFTIRQ);

init_timers
	open_softirq(TIMER_SOFTIRQ, run_timer_softirq);
		struct tvec_base *base = __this_cpu_read(tvec_bases);
		if (time_after_eq(jiffies, base->timer_jiffies))

cascade(base, &base->tv2, INDEX(0))
#define INDEX(N) ((base->timer_jiffies >> (TVR_BITS + (N) * TVN_BITS)) & TVN_MASK)			

	이해 안 가는 부분이 INDEX 부분인데, 현재 이 루틴이 하는 바를 이해하지 못해서이다.
	timer_jiffies의 값은 timer 루틴이 현재 알고 있는, 가장 가까운 만료 jiffies 값이다.
	이 값이 현재 jiffies 보다 작기 때문에 처리해야 할 timer를 찾는 과정을 수행하는 것이고, ..

	    Q. tvec은 array인데, timer_jiffies를 기준으로 하는 INDEX가 특정 array 중 하나가 아닌 or-ing을 나타내게 되지 않나?
	    Q. cascade에서 tvec에 timer가 있어서 옮겨 달고 나면 다음 tvec을 처리하지 않는데, 이렇게 되면 나머지 타이머들은 현재 timer_jiffies에 맞지 않는 자리에 위치한다.


ida_init
ida_pre_get
	ida_get_new

gcwq [percpu와 unbound_global_cwq]로 존재 (UNBOUND까지 별도의 cpu라 본다면 1:1 관계이다)
	pool [normal과 highpri]로 존재

wq
	cwq ; cwq는 per-cpu wq로 cpu마다 존재한다.
		pool ; gcwq의 특정 pool을 가리키는데, 연결하는 조건이..?
	resquer ; gcwq와 독립적인 worker이며, 별도의 thread로 수행한다.

qcwq


cwq ; workqueue 생성시 만들어 준다.

worker
	scheduled ; 처리해야 할 work의 리스트
	task ; 실행할 thread 구조체.

http://criticalblue.com/news/wp-content/uploads/2013/12/linux_scheduler.pdf


cpu_stopper_thread
	migration/%d


hrtimer_cpu_notify에서
	clockevents_notify를 호출한다.

tick_init
	clockevents_register_notifier(&tick_notifier);

clockevents_do_notify

softirq
	.notifier_call = cpu_callback,

	.notifier_call = remote_softirq_cpu_notify,

timer_cpu_notify

kthread_create_on_node <-> kthreadd가 전역 리스트에 등록된 create 요청을 처리하고 complete을 날리는 과정

sched_class
http://criticalblue.com/news/wp-content/uploads/2013/12/linux_scheduler.pdf

stop	=> rt	=> fair	=> idle
(percpu)                   (percpu)


* copy_process 분석 필요.
* cmwq 정리



secondary_startup			// arch/arm/kernel/head.S
	secondary_start_kernel		// 


arch/arm/mm/proc-v7-2level.S
	#define TTB_FLAGS_SMP   TTB_IRGN_WBWA|TTB_S|TTB_NOS|TTB_RGN_OC_WBWA
	#define PMD_FLAGS_SMP   PMD_SECT_WBWA|PMD_SECT_S

CONFIG_CPU_HAS_ASID
mcr p15, 0, r1, c13, c0, 1
mcr p15, 0, r0, c2, c0, 0


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

* cpu_init() 함수에서 irq, abt, und mode로 전환하면서 stacks array를 각 모드의 sp로 저장한다.

* vector_stub 어셈블리 매크로를 보면 어떤 모드에서 stub으로 진입 했든 항상 svc 모드로 전환하는 과정을 볼 수 있다.

* 그렇다면 왜 항상 svc모드로 전환하는가?
	같은 질문이 stackoverflow에 올라와 있는데, 이렇게 처리했을 때의 장점은 두 가지다.

	(irq -> svc를 중심으로 한 설명이다)
	1. IRQ mode를 위한 별도의 stack이 필요하지 않다.
	2. SVC 모드로 전환함으로써 새로운 interrupt를 핸들링 할 수 있다.
	http://stackoverflow.com/questions/7915255/why-does-linux-arm-always-switch-to-supervisor-mode-during-exception-handling
	http://stackoverflow.com/questions/22928904/linux-kernel-arm-exception-stack-init

	[참고] arm exception
		http://www.ic.unicamp.br/~celio/mc404-2013/arm-manuals/ARM_exception_slides.pdf
	
* 참고자료
	Interrupt handling in ARM
	http://venkateshabbarapu.blogspot.kr/2012/09/interrupt-handling-in-arm.html

	How ARM Supervisor Call Exception Handled in Linux
	http://pr1mary.blogspot.kr/2013/11/how-arm-supervisor-call-exception.html

	http://arm-linux-interview-questions.blogspot.kr/2013/04/arm-linux-abort-handler-implementation.html

* arm linux kernel은 7개의 processor mode 중 어떤 모드에서 수행되나? (USR, IRQ, FIQ, SVC, ABT, UND, SYS ; sys가 os task를 위한 privileged mode이다)
	SVC mode 에서 수행된다.
	arm kernel 요구사항으로 svc 상태여야 한다는 내용.
	https://www.kernel.org/doc/Documentation/arm/Booting

	arm64에서는 별 말이 없다?
	https://www.kernel.org/doc/Documentation/arm64/booting.txt


__stubs_start:
	vector_stub irq, IRQ_MODE, 4				// vector_irq 선언. correction 값은 익셉션 핸들링이 끝나고 어느 상태로 돌아가야 하나.
	.long	…
	.long   __irq_svc           @  3  (SVC_26 / SVC_32)

	vector_stub dabt, ABT_MODE, 8
	.long	…

	ector_stub pabt, ABT_MODE, 4
	.long	…
	
__stubs_end:

	.equ    stubs_offset, __vectors_start + 0x200 - __stubs_start


__vectors_start:
	…
	W(b)    vector_irq + stubs_offset
	…
__vectors_end:

sd_data 구성위치 : __sdt_alloc

CONFIG_TMPFS
CONFIG_DEVTMPFS 가 정의되지 않아 devtmpfs_init.


shmem_init

* Shared Memory Virtual Filesystem
https://www.kernel.org/doc/gorman/html/understand/understand015.html
	file이나 device에 해당하는 영역의 메모리 공유는 mmap() 함수로  MAP_SHARED라는 플래그를 주어 할 수 있다. 그러나 anonymous 영역에 대한 메모리 공유가 필요한 두 가지 케이스가 있다.
	mmap()에 MAP_SHARED가 주어졌지만 file backing이 아닐 경우와 shmget()으로 할당받고 shmat()으로 v.a.에 붙일 경우이다.



[별도] CMA, GCMA
	http://gurugio.blogspot.kr/2014/05/cma-contiguous-memory-allocation.html
	https://lwn.net/Articles/480055/
	https://lwn.net/Articles/486301/
	https://events.linuxfoundation.org/images/stories/pdf/lceu2012_nazarwicz.pdf
	http://events.linuxfoundation.org/sites/events/files/slides/gcma-guaranteed_contiguous_memory_allocator-lfklf2014_0.pdf

uevent

* Linux Device Driver Chapter 14.
	kobjects
		- Reference counting of objects
		- Sysfs representation
		- Data structure glue
		- Hotplug event handling : hardware의 연결/제거를 user space에 알리는 events 생성을 다룬다.

	kset
	ktype

* struct class, struct bus_type, struct device, struct device_driver 선언 위치
	include/linux/device.h

* struct subsys_private 선언위치
	drivers/base/base.h

* struct subsys_private priv;
  struct bus_type bus;

	버스 등록시 서로 연결된다.
	priv.bus = bus;
	bus.p = priv;

subsys_private	; bus_type과 class 구조체에 공통으로 포함된 자료구조로, 드라이버 core의 private 데이터(주로 관리용 자료구조)를 포함한다.
	struct kset subsys;

driver_private

klist_node ; klist ?


struct device_private
	.device로 해당 struct device를 가리킨다.
struct device


kobject_uevent_env()

bus_register(subsys)
	__bus_register에서 drivers_autoprobe = 1;


subsys_system_register
	bus_register


* klist iterate
	klist_iter_init_node(&klist, &klist_iter, …)
		; klist를 순회하기 위한 klist_iter를 채운다.
	while ((dev = next_device(&i)))
		; klist_iter로 순회한다.
		  next_device()는 klist_next로 iter를 이용한다.
		  struct klist_node *klist_next(struct klist_iter *i)
	klist_iter_exit(&i)


device_release_driver

topology_init
	register_cpu


gic_init
	gic_init_bases
		alloc_irq_descs? 해서 irq_desc를 할당


prepare_to_wait			<- wake_up() 깨워준다.
schedule_timeout(timeout);
finish_wait

initcall 분석 중...

initcall level
	0 - early
	1 - core
	2 - postcore
	3 - arch
	4 - subsys
	5 - fs
	6 - device
	7 - late


* namespace
	CONFIG_NAMESPACES

	namespace를 사용하는 경우 
	/proc/<PID>/ns 아래 UTS, IPC, PID, NET, MNT 파일들이 생성된다.

* ptrace
	Process Tracer
	

[Cortex-A series PG]	Table 11-3 Link Register Adjustments
Exception		Adjustment		Return instruction		Instruction Returned to
SVC			0			movs pc, r14			Next instruction
Undef			0			movs pc, r14			Next instruction
Prefetch Abort		-4			subs pc, r14, #4		Aborting instruction
Data abort		-8			subs pc, r14, #8		Aborting instruction if precise
FIQ			-4			subs pc, r14, #4		Next instruction
IRQ			-4			subs pc, r14, #4		Next instruction


* undefined instruction (UND exception)
	: 정의되지 않은 명령어가 execute level에서 실행
	  예를 들어 코프로세서 명령어가 실행되었지만, 해당 coprocessor가 없을 경우 undefined instruction exception 발생.
	

	__und_svc:
		svc_entry


	__und_svc_fault:

	__und_fault
		b do_undefinstr.
			call_undef_hook		// register_undef_hook로 등록된 hook에 지정된 함수를 호출한다.


———————————————————————
add r7, sp, #S_SP - 4   @ here for interlock avoidance
mov r6, #-1         @  ""  ""      ""       ""
add r2, sp, #(S_FRAME_SIZE + \stack_hole - 4)

#define S_SP 52 /* offsetof(struct pt_regs, ARM_sp) @ */




ldmia   sp, {r0 - pc}^          @ load r0 - pc, cpsr

ARM condition codes
————————+————————————————————————————————————————————————————————————————————————
Suffix	|	Flags				Meaning
————————+————————————————————————————————————————————————————————————————————————
EQ	|	Z = 1				Equal
NE	|	Z = 0				Not equal
CS/HS	|	C = 1				Higher or same (unsigned >= )
CC/LO	|	C = 0				Lower (unsigned < )
MI	|	N = 1				Negative
PL	|	N = 0				Positive or zero
VS	|	V = 1				Overflow
VC	|	V = 0				No overflow
HI	|	C = 1, Z = 0			Higher (unsigned > )
LS	|	C = 0 or Z = 1			Lower or same (unsigned <= )
GE	|	N == V				Signed >=
LT	|	N != V				Signed <
GT	|	Z = 0, N == V			Signed >
LE	|	Z = 1, N != V			Signed <=
AL	|	Any				Always (usually omitted)
————————+————————————————————————————————————————————————————————————————————————

svc_entry
…
svc_exit



head.S에서 가장 먼저 수행하는 코드
	: SVC 모드에서 수행한다.
	setmode PSR_F_BIT | PSR_I_BIT | SVC_MODE, r9 @ ensure svc mode and irqs disabled


early_trap_init
	vector용으로 할당 받은 페이지에 복사
	0x0		: __vector_start ~ __vector_end		// vector table
	0x200 		: __stubs_start ~ __stubs_end		// stub macro
	0x1000-kuser_sz	: __kuser_helper_start ~ (0x1000-1)	// kuser_helper

kexec - kexec is a system call that implements the ability to shutdown your current kernel, and to start another kernel.
	It is like a reboot but it is independent of the system firmware.   And like a reboot you can start any kernel with it, not just Linux.

	“UEFI secure boot”을 kexec가 우회 했었는데, 3.17에서 signed된 kernel만 올릴 수 있도록 패치가 적용되었다.
	http://kernelnewbies.org/Linux_3.17
	http://lwn.net/Articles/603116/

	arm trust zone을 사용하는 secure os를 사용하기 위해 커널 3.18 이상을 사용...

	http://elinux.org/images/2/2f/ELC-2010-Damm-Kexec.pdf

kexec/kdump : http://www.openseed.co.kr/1



case SYSFS_KOBJ_BIN_ATTR:

fs/sysfs/bin.c
const struct file_operations bin_fops = {
	…
};


“notes”
ELFNOTE 매크로로 지정해 주지 않았는데 왜 .notes 섹션이 보일까?
	http://kernelnewbies.org/vmlinux/asm-notes
	https://lwn.net/Articles/531148/


fsnotify
flock
binfmt_XXX : binfmt_script (default), binfmt_elf, ..got

mount_single
debugfs같은 파일시스템은 하나의 instance를 공유한다. (test시 항상 참을 리턴)
https://www.kernel.org/doc/Documentation/filesystems/vfs.txt


dentry 할당의 의미는 무엇인가? (d_alloc)
d_add


random32_init 부터...

RCU_INIT_POINTER
rcu_dereference_protected(p, c)
// include/linux/rcupdate.h

// d_lookup은 parent와 name 쌍을 사용한다.
struct dentry *d_lookup(struct dentry *parent, struct qstr *name)
	d_lookup searches the children of the parent dentry for the name in question
	내부에서 __d_lookup 호출

__d_lookup_rcu ; 왜 rcu 버전이 별도로 존재하는가?


lru : superblock에 s_dentry_lru 리스트로 관리된다.


hlist_bl_add_head_rcu 호출하는 함수: __d_rehash, d_obtain_alias



struct net : include/net/net_namespace.h
sturct net_generic : include/net/netns/generic.h

include/linux/skbuff.h
struct sk_buff

include/linux/net.h
struct socket
	struct file *file
	struct sock *sk
	struct proto_ops *ops


netlink_create
netlink_kernel_create

uevent_net_init
	netlink_kernel_create
		sock_create_lite
			sock_alloc


struct dentry *mount_pseudo(struct file_system_type *, char *name, super_operations, dentry_operations, magic)
 : sockfs는 sockfs_ops, sockfs_dentry_operations
	

/proc/net/netlink
	group의 의미

listeners의 의미
	http://softengcrunch.blogspot.kr/2010/12/communicating-with-kernel-via-netlink.html


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

bus_register(amba)

struct bus_type
	struct subsys_private

struct class
	struct subsys_private

* http://lxr.free-electrons.com/source/Documentation/driver-model/bus.txt


subsys_system_register(bus_type을 등록한다) “/sys/bus/cpu”
subsys_interface_register(&s3c2440_clk_interface);		// 버스가 이미 등록된 상태에서 bus->subsys_private->interface에 등록한다.

device_create(struct class, …)


/proc/<PID>/maps : vma 정보
/proc/<PID>/pagemaps : pagetable

https://www.kernel.org/doc/Documentation/filesystems/proc.txt
https://www.kernel.org/doc/Documentation/vm/pagemap.txt


platform device 등록시 지정한 resource의 ioports와 iomem 타입 정보는 /proc/ioports, /proc/iomem을 통해 확인할 수 있다.

fsr_info (이 테이블은 ARM ARM ‘Table B3-23 Short-descriptor format FSR encodings’ p.1406에 해당한다)
	do_DataAbort, do_PrefetchAbort에서 어떻게 사용되는가?

hook_fault_code, hook_ifault_code를 사용해 fsr_info를 업데이트 한다.
	=> architecture version에 따라 달라질 경우
	=> hw_breakpoint 사용시 trap 처리가 필요할 경우


.macro define_processor_functions name:req, dabort:req, pabort:req, …

define_processor_functions v7, dabort=v7_early_abort, pabort=v7_pabort, …

	=> dabort는 어떻게 사용되지? processor_functions를 kernel에서 가리키는 구조체가 있을텐데?
		arch/arm/include/asm/proc-fns.h 의 struct process 내에 _data_abort가 있음

		arch/arm/include/asm/procinfo.h 의 struct proc_info_list 내에 struct process가 있음

arch/arm/include/asm/glue-df.h : Data Abort Model
	v7_early  - ARMv7 generic early abort handler

	define CPU_DABORT_HANDLER v7_early_abort
	// 	arch/arm/mm/abort-ev7.S 사용 (MULTI_DABORT가 아니다)

arch/arm/include/asm/glue-pf.h : Prefetch Abort Model
	v7        - ARMv7: IFSR and IFAR


arch/arm/kernel/entry-armv.S
	.macro dabrt_helper

__dabt_svc:
	svc_entry
	..
	dabt_helper	-> CPU_DABORT_HANDLER // v7_early_abort -> do_DataAbort




/sys/bus/amba/drivers/mmci-pl18x # ls
bind
mb:mmci -> ../../../../devices/mb:mmci
uevent
unbind

/sys/bus/amba/drivers/mmci-pl18x # unbind “mb:mmci” > unbind
/sys/bus/amba/drivers/mmci-pl18x # ls
bind
uevent
unbind

/sys/bus/amba/drivers/mmci-pl18x # unbind “mb:mmci” > bind
mmci-pl18x mb:mmci: mmc0: PL181 manf 41 rev0 at 0x10005000 irq 41,r2 (pio)
/sys/bus/amba/drivers/mmci-pl18x # ls
bind
mb:mmci -> ../../../../devices/mb:mmci
uevent
unbind



uevent…
kobject_uevent
	kobject_uevent_env

alignment_init
clocksource_done_booting

anon_inode_init
populate_rootfs

sched_clock_syscore_init
timer_init_syscore_ops
proc_execdomains_init
ioresource_init
uid_cache_init



/proc/kallsysms have symbols of dynamically loaded modules as well static code and system.map is symbol tables of only static code.


MODULE_VERSION(..) 사용한 모듈들
	xz_dev, libata, smsc911x,tcp_cubic, 


stop_sched_class
	cpu_stopper_thread



http://criticalblue.com/news/wp-content/uploads/2013/12/linux_scheduler.pdf

#define for_each_class(class) \
	for (class = sched_class_highest; class; class = class->next)


struct sched_class
struct sched_entity

timekeeping_init
clocksource_change (v2m_timer1) 로그 출력
rtc 드라이버 초기화

부팅 후 timerkeeper의 값을 display 해보니 1449xxxxxx.
연도로 계산하면 45년.
UTC 1970 + 45 => 2015



stop_machine -> stop_cpus

eventfd 예제
3 -> anon_inode:[eventfd]

unlink 삭제 예제
삭제전: /home/freestyle/kernel/iamroot9C/debug_with_qemu/test_code/anon_inode/file
삭제후: /home/freestyle/kernel/iamroot9C/debug_with_qemu/test_code/anon_inode/file (deleted)

1. argument를 전달하는 부분
2. argument pool에 파싱 함수를 등록하는 부분


parse_args(“early options”, …, do_early_param)
parse_args(“Booting kernel”, …, unknown_bootoption)
	parse_one 호출
		- early_init


lds 매크로 RO_DATA_SECTION에 의해 거의 마지막에 아래와 같이 배치
	__start__param
	*(__param)	<- __level_param_cb() / core_param(), module_param() -> 결국 __module_param_call
	__end__param

lds 매크로 INIT_SETUP에 의해 아래와 같이 배치.
	__setup_start
	*(.init.setup)	<- 여기에 등록해주는 매크로는 __setup()
	__setup_end

__setup 등록





initrd
	=> initial ram disk. bootloader가 메모리에 필요한 파일을 올리고 커널에게 제어를 넘긴다. 커널은 real root filesystem으로 교체해 작업한다.
	gzipped filesystem image. ext2 같은 파일포맷으로 생성.
initramfs => cpio

rootfs

CONFIG_BLK_DEV_INITRD=y
CONFIG_INITRAMFS_SOURCE=""
	=> initramfs 사용시

CONFIG_BLK_DEV_RAM
	=> block device : ext2 등으로 꾸며진 rootfs를 mount하기 위한 설정.


android
	CMDLINE root=/dev/ram init=/init
	rootfs.img
	/system
	/data
	/cache


식사 후 ramfs 분석
https://www.kernel.org/doc/Documentation/filesystems/ramfs-rootfs-initramfs.txt

“ramfs”
	Ramfs는 매우 간단한 파일시스템으로, 리눅스의 디스크 캐시 매커니즘(page cache와 dentry cache)을 export 한다.
	동적으로 재조정 가능한 ram-based 파일시스템이다.

	ramfs로 사용된 페이지들은 backing device에 쓰이지 못하기 때문에 clean되지 않는다.

	=> 리눅스에서 다음과 같이 mount 해 사용 가능하다. 주어진 size 이상으로 data를 계속 쓸 수 있다.
	mount -t ramfs -o size=5m tmpfs /mnt/ram1

	=> 다음과 같이 mount 하였을 경우, block device operation이 호출될까???
	mount -t ramfs /dev/ram0 /mnt/ram2

“ram disk”
	보다 오래된 ram disk 메커니즘은 RAM 외에 공간에 파일시스템을 위한 의미론적 block device를 만들고 backing store로 사용한다.
	block device는 고정된 크기이므로 그곳에 마운트된 파일시스템도 고정된 크기다.
	fack block device와 page cache 사이에 불필요한 메모리 복사가 일어난다. 여기에 dentry까지 생성하고 삭제된다.
	ext2 같이 이를 포맷하고 데이터를 처리할 파일시스템도 필요하다.

	ramdisk는 보다 유연하고 편리한 인터페이스를 제공하는 loopback device의 등장으로 구식이 되었다.
	loopback device는 메모리 덩어리가 아니라 파일에 의미론적 블럭 디바이스를 생성한다.

“tmpfs”
	ramfs는 모든 메모리를 다 쓸 때까지 계속해서 쓸 수 있고, VM은 ramfs가 backing store를 갖지 못하므로 free시키지 못한다.
	root나 권한이 부여된 user만이 ramfs mount에 write access가 허용된다.

	ramfs에서 파생된 tmpfs는 size제한을 둘 수 있고, swap space에 data를 쓸 수 있다. 따라서 일반 user도 사용 가능하다.
	See Documentation/filesystems/tmpfs.txt.

“rootfs”
	ramfs의 특별한 인스턴스이다(tmpfs가 선택되었다면 tmpfs). init process를 죽이지 못하는 것과 같은 이유로 rootfs를 언마운트를 할 수 없다.
	kernel은 empty list를 처리하는대신 empty list가 될 수 없도록 처리했다.

	대개 시스템은 rootfs 위로 다른 파일시스템을 마운트하고 rootfs를 무시한다.

“initramfs”
	2.6버전부터 gziped “cpio” format archive를 포함되는데, 부팅하며 rootfs에 풀린다.
	압축 해제 후, rootfs 내에서 init을 찾아 PID 1로 실행시킬 수 있는지 검사하는데, 가능하다면 init으로 real root device를 위치시키고 마운트 시킨다.
	init을 찾지 못하면 이전 코드부분에서 root partition을 배치시키고 마운트 시켜 /sbin/init의 변종을 실행한다.

https://www.kernel.org/doc/Documentation/early-userspace/buffer-format.txt
https://www.kernel.org/doc/Documentation/blockdev/ramdisk.txt

scripts/gen_initramfs_list.sh

struct task_struct -> struct cred -> struct user_struct

/sys/kernel/slab : 전체 slab 정보. merge된 것들은 alias로 보여준다.
/proc/slabinfo : merge되고 실제 존재하는 slab cache 목록만 보여준다.


__copy_to_user, __copy_from_user 분석 해보자…

gettimeofday : CLOCK_REALTIME과 같은 특성. deprecated.

process_cpu_timer_create : break point를 걸어도 호출되지 않았음.



suspend_devices_and_enter
	dpm_suspend_start



tick_suspend
	struct tick_device *td = &__get_cpu_var(tick_cpu_device);

	struct tick_device {
		struct clock_event_device *evtdev;	// tick_setup_device에서 설정
		enum tick_device_mode mode;
	};


percpu_timer_setup
	struct clock_event_device *evt = &per_cpu(percpu_clockevent, cpu);




qemu 실행순서 trace
1. schedule_preempt_disabled()
2. __schedule()
3. __schedule()
4. __schedule()
5. kthreadd
6. kernel_init



==============================================================================================================================
- twd_handler 등록과정
	MACHINE VEXPRESS
		.init_irq = v2m_init_irq
			ct_desc->init_irq() => ct_ca9x4_init_irq => gic_init, ca9x4_twd_init => twd_local_timer_register => twd_local_timer_common_register
				request_percpu_irq(twd_ppi, twd_handler, “twd”, twd_evt)

- twd_handler 호출순서
	gic_handle_irq
		handle_IRQ
			generic_handle_irq
				generic_handle_irq_desc
					handle_percpu_devid_irq (irq=29) ; PPI
						twd_handler

- twd_handler 동작
	if twd_timer_ack()
		evt->event_handler(evt);	// evt는 clock_event_device

- event_handler의 등록 위치
	tick_set_periodic_handler		// periodic한 clock event (tick과 같은)에 대한 이벤트 핸들러 지정.
		if (!broadcast)
			dev->event_handler = tick_handle_periodic;	// core마다 호출된다.
		else
			dev->event_handler = tick_handle_periodic_broadcast;

- tick_handle_periodic
	tick_periodic(cpu);
		if (tick_do_timer_cpu == cpu) {
			tick_next_period = ktime_add(tick_next_period, tick_period);
			do_timer(1);
				jiffies_64 += ticks;
				update_wall_time();
				calc_global_load(ticks);
		update_process_times(user_mode(get_irq_regs()));
		profile_tick(CPU_PROFILING);


Q. scheduler는 각 cpu마다 수행되나?
	__schedule은 그냥 함수. 호출 가능한 시점이 되면 어느 core에서든 호출된다. runqueue에 등록된 task 중 하나를 선택해 호출한다.
Q. scheduler_tick이란?
Q. tick은 각 core마다 발생하나?
==============================================================================================================================

* request_percpu_irq와 enable_percpu_irq 분석할 것

	twd_timer_setup			// twd_local_timer_common_register에서 request_percpu_irq로 twd 등록 후 local_timer_register에서부터 호출.
		clockevents_config_and_register(clk, twd_timer_rate, 0xf, 0xffffffff); //clock_event_device를 설정하고 등록한다.
		enable_percpu_irq(clk->irq, 0)

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

인터럽트(irq) 호출 순서

__irq_svc		// setup_arch에서 handle_arch_irq에 machine의 handle_irq를 저장해 두었다.
	=handle_arch_irq 로 pc이동

MACHINE VEXPRESS
	.handle_irq = gic_handle_irq
		handle_IRQ

handle_IRQ(irq, regs)
	old_regs = set_irq_regs(regs)
	irq_enter()				// add_preempt_count(HARDIRQ_OFFSET)
	generic_handle_irq(irq)
	irq_exit()				// 
	set_irq_regs(old_regs)

generic_handle_irq
	generic_handle_irq_desc(irq, desc)
		irq_desc desc = irq_to_desc(irq)
		generic_handle_irq_desc(irq, desc)
			desc->handle_irq(irq, desc)

static int __init init_workqueues(void)
early_initcall(init_workqueues);
	create_worker
		kthread_create_on_node
		kthread_create

schedule_work
	queue_work
		queue_work_on

	- try_to_wake_up()에서 현재 프로세스보다 높은 우선 순위를 가진 프로세스가 깨어난 경우
		check_preempt_curr()


* TIF에 NEED_RESCHED를 기록하는 부분
tick_handle_periodic
	tick_periodic		// periodic tick인 경우
		update_process_times
			scheduler_tick
				curr->sched_class->task_tick()



.task_tick = task_tick_fair;	// scheduler tick hitting a task of our scheduling class:

for_each_sched_entity(se)
	entity_tick

		check_preempt_tick	// fair.c: Preempt the current task with a newly woken task if needed:
			resched_task	// TIF에 need_resched set.



* resched_task를 호출하는 다른 예

ttwu_do_wakeup
	check_preempt_curr()



* TIF에서 NEED_RESCHED를 검사해 호출하는 부분
	__irq_svc
		svc_entry
		irq_handler
		TIF check 후 svc_preempt
			preempt_schedule_irq
				local_irq_enable
				__schedule
				local_irq_disable
		svc_exit


	ret_to_user
		_TIF_WORK_MASK(
		work_pending



* timer에 의한 동작
	run_local_timers
		raise_softirq(TIMER_SOFTIRQ)
			raise_softirq_irqoff
				wakeup_softirqd
					wake_up_process
						try_to_wake_up
	
		

__switch_to에서 마지막에 pc 바뀌면 이후의 코드가 수행이 안 되는 게 아닌가?

sys_syscall
	sys_fork_wrapper
	sys_clone_wrapper


sys_fork_wrapper
	add r0, sp, #S_OFF	@ r4/r5 register


(function call이 아니라 exception으로 r4, r5를 레지스터로 전달)

do_fork…

switch_new_context
	__new_context
	cpu_switch_mm



http://www.2cto.com/os/201411/349997.html
https://lwn.net/Articles/383162/
http://barriosstory.blogspot.kr/2010/02/improve-scalability-of-rmap-scanning-of.html

anon_vma_chain_link

__do_page_fault
	vma = find_vma(mm, addr)
	handle_mm_fault(mm, vma, …)
		handle_pte_fault
			do_swap_page
			do_wp_page

* vm_file
	

* struct address_space의 역할?

페이지 캐시 : 디스크에 접근시 시간이 오래 걸리므로 읽은 데이터를 물리적 페이지에 저장하는 기법.
	- 디스크에 접근한 데이터만 페이지 캐시로 생성되나?
한 번 접근한 데이터를 다시 접근하면 이 페이지 캐시를 뒤져 page를 리턴하는데, 물리적 블럭이 캐시된 페이지를 찾을 때 address_mapping이라는 구조체를 참조하게 된다.

페이지가 페이지 캐시로 사용될 때, address_space를 mapping이라는 포인터로 가리킨다.

task_struct->file->f_dentry->d_inode->i_mapping
	
	find_get_page(mapping, index);		


pgoff_t index; /* Our offset within mapping. */


vfs에서 file을 읽어올 경우
1) page cache를 안 쓸 경우
2) page cache를 쓸 경우


* address_space_operations
	각 fs마다 구현해 놓는다.


address_space는 page cache를 구현하는, 아주 중요한 역할을 하는 구조체이다.
또한 실제로 파일시스템에서 블록을 읽기 위한 기능을 구현하는 address_space_operations 구조체를 포함하기도 한다. 

file_operations 구조체는 응용 프로그래머들이 일반적으로 사용하는 open, read, write, close, ioctl, mmap 등과 연관되는 함수이다.
일반적으로 file_operations의 함수들은 최종적으로 address_space_operations의 함수들을 호출해 실제적으로 block device에서 페이지들을 읽게 된다.




inode <-> address_space 1:1 매핑

- page cache 는 struct address_space 구조체로 관리됩니다.
- 보통 inode에 들어 있는데요, i_mapping 변수 입니다.
- struct address_space 구조체의 page_tree 를 따라가시면 현재 page cache 에서 캐쉬하고 있는 각 page 를 알수 있습니다. (따라가는 부분은 linux 소스 코드를 확인해 보세요)
- 즉, struct page 구조체 정보를 알수 있는데요, struct page 구조체 정보에서 실제 물리주소 정보를 알아내실수 있을듯 합니다.





raw_spin_is_contended 에 대한 주석 달기

향후 진행 방향
	- copy_process 분석 후 리눅스 커널의 이해를 기준으로 소스 분석
	- aarch64 학습
책

check_and_switch_context
	if (!((mm->context.id ^ cpu_last_asid) >> ASID_BITS))
	else if (irqs_disabled())
	else
		switch_new_context(mm);		
			__new_context(mm);
				…
				flush_context();
				smp_call_function(reset_context, NULL, 1);
			cpu_switch_mm(mm->pgd, mm);


contextidr p.1532

config PID_IN_CONTEXTIDR 설정된 경우에만. (vexpress는 설정 안 되어 있음)
	Say Y here only if you are planning to use hardware trace tools with this kernel.

contextidr_notifier
	asm volatile(
	"   mrc p15, 0, %0, c13, c0, 1\n"	// read contextidr
	"   bfi %1, %0, #0, %2\n"
	"   mcr p15, 0, %1, c13, c0, 1\n"
	: "=r" (contextidr), "+r" (pid)
	: "I" (ASID_BITS));







mmap, vm_area_struct

https://www.kernel.org/pub/linux/kernel/people/mochel/doc/papers/ols-2005/mochel.pdf

http://hoonycream.tistory.com/entry/udev
http://iamhjoo.tistory.com/17
https://www.google.co.kr/search?q=uevent&biw=1276&bih=705&tbm=isch&imgil=bk36wyBJFm-jqM%253A%253BedAaDp9ntgpLsM%253Bhttp%25253A%25252F%25252Fshunzi610747304.blog.163.com%25252Fblog%25252Fstatic%25252F509997342011101441223936%25252F&source=iu&pf=m&fir=bk36wyBJFm-jqM%253A%252CedAaDp9ntgpLsM%252C_&usg=__SjFnjwDdQuKIGTJbNBsO-gLXiaA%3D#imgrc=bk36wyBJFm-jqM%3A&usg=__SjFnjwDdQuKIGTJbNBsO-gLXiaA%3D
https://www.kernel.org/doc/pending/hotplug.txt
http://com.odroid.com/sigong/nf_board/nboard_view.php?brd_id=odroidseven&bid=415
http://stackoverflow.com/questions/22803469/uevent-sent-from-kernel-to-user-space-udev
http://blog.daum.net/baramjin/16011051
https://www.google.co.kr/?gws_rd=ssl#q=sysfs+attribute+groups
http://kroah.com/log/blog/2013/06/26/how-to-create-a-sysfs-file-correctly/

zlam, zcache?

절반은 aarch64 분석 / 절반은 커널 소스 분석


1) AArch64 분석
	: ARMv8 Architecture PG (296 pages)   에상(5~6장)
		용도가 다양하다.
		- kernel
		- llvm backend
		- hypervisor

2) 커널 소스분석
	: 현재 분석 중인 코드
		do_fork는 분석 완료. 추가로 볼 function에 대한 것 추가로 몇 가지.

	: OS 책
		understanding linux kernel 3판 (2.6) 학습 & 현재 커널에서 코드로 확인 (20주)

	: embedded os 전체를 볼 수 있으며 / 분석하기 편한 작은 코드량 (전원찬님)
	  aarch64, 많은 Document, 많은 개발자가 붙어 있는 os (나)

	  secure os - Trusty TEE(추후 공개 예정, os?), tlk, OP-TEE/optee-os, OPEN-TEE
	  micro kernel - freeRTOS, uCOS
             hypervisor(kvm) -
	  IoT os - 
	  automotive os - 

	: new version linux
		시간이 많이 필요함. 새로 보는 수준일 것

* 볼 것
	do_fork
		copy_process
			copy_mm
				dup_mm
					dup_mmap
						copy_page_range
							copy_pud_range
								copy_pmd_range
									copy_pte_range

	전원찬님
	* TEE OS 같은 소스 분석
	* aarch64 보는 방식, 범위
		memory 관리?


	do_execve
	user mode에서 kernel로 전환하는 과정 <-> ret_to_user

	scheduler
	context_switch

	initcall 나머지 부분들

	vma 관리

	smp에서 다른 core들이 idle 상태에서 언제 스케쥴링 되어 태스크를 실행하는지


* cpuset
* cgroup

* RCU

* page fault
* interrupt handling

* scheduling
	sched_class / sched_domain, sched_group

* context switching

* vm_area_struct
	.vm_ops

[llvm]
	http://www.slideshare.net/Hybrid0/llvm-28276305
	http://www.aosabook.org/en/llvm.html
	http://en.wikipedia.org/wiki/LLVM
	http://clang.llvm.org/
	http://llvm.linuxfoundation.org/index.php/Main_Page

[gcc]

	http://gcc.gnu.org/onlinedocs/gccint
	http://gcc.gnu.org/onlinedocs/gcc/Debugging-Options.html

GCC Intermediate Representations (1) - GENERIC (tree)
	http://studyfoss.egloos.com/5117056
GCC Intermediate Representations (2) - GIMPLE
	http://studyfoss.egloos.com/5167039

spec 파일 이용하기
	http://studyfoss.egloos.com/5037962
gcc 실행 과정
	http://studyfoss.egloos.com/5273402
컴파일러 실행 과정
	http://studyfoss.egloos.com/5274269
컴파일 최적화 과정 - 개요
	http://studyfoss.egloos.com/5276500

__define_initcall()을 재정의. 호출 순서와 section이 지정
initcall_debug를 enable 해서 살펴볼 것.


kernel_init
	do_basic_setup
		do_initcalls // loop을 돌면서 등록한 함수들 순차적으로 실행
			do_initcall_level

svn_preempt

svc_exit




.macro

* http://www.cse.unsw.edu.au/~cs9242/08/lectures/04-cachex6.pdf
* http://en.wikipedia.org/wiki/CPU_cache
* What every programmer should know about memory, Part 1
	http://lwn.net/Articles/250967/
	http://lwn.net/Articles/252125/
	http://lwn.net/Articles/253361/

- kernel을 local build할 수 있다고 하는데, 무슨 말이지?