삼월

포트번호 없이 ip 만으로 접속

삼월은마치 — Mon, 4 Nov 2024 14:59:29 +0900

기존에는 ip주소에 포트번호 8080까지 붙여줘야만 접속이 가능했다.

이걸 간단히 생략하고 ip주소만으로 접속하는 방법에 대해 알아왔다.

iptables 설정을 초기화 하고 원하는 포트번호(ex:8080)가 기본값인 80으로 redirection되게 해 주면 된다.

$ sudo iptables -F -t nat
$ sudo iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-ports 8080

중간엔 공백 오타다. 1. 2로 표시한 부분만 보자.

접속이 잘 된다.

예전에 nginx로 해야하는 줄 알고 삽질했던 때가 생각난다.

굉장히 간단했다.

reference

https://eng-sohee.tistory.com/105

[Sorting] 56. Merge Intervals

삼월은마치 — Thu, 24 Oct 2024 00:13:27 +0900

https://leetcode.com/problems/merge-intervals/description/

Given an array of intervals where intervals[i] = [starti, endi], merge all overlapping intervals, and return an array of the non-overlapping intervals that cover all the intervals in the input.

Example 1:

Input: intervals = [[1,3],[2,6],[8,10],[15,18]]
Output: [[1,6],[8,10],[15,18]]
Explanation: Since intervals [1,3] and [2,6] overlap, merge them into [1,6].

Example 2:

Input: intervals = [[1,4],[4,5]]
Output: [[1,5]]
Explanation: Intervals [1,4] and [4,5] are considered overlapping.

Constraints:

1 <= intervals.length <= 104
intervals[i].length == 2
0 <= starti <= endi <= 104

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        
        intervals.sort(key=lambda x: x[0]) #정렬기준 key를 오름차순으로 정렬 시, start=x[0]을 기준으로 함

        result = []
        if intervals:
            cur = intervals[0] #초기값 설정 ex cur = [1,3]

            for next in intervals[1:]: #start = 1부터 순차적으로 탐색

                if next[0] <= cur[1]:
                    cur[1] = max(cur[1], next[1]) #병합
                else:
                    result.append(cur) #그냥 추가
                    cur = next #다음 [start, end]요소 받기
            result.append(cur) #순차적으로 next를 result에 추가
        
        return result

리스트의 요소 x에 대해 x[0]=start를 기준으로 오름차순 정렬하겠다.

오름차순

intervals.sort(key=lambda x: x[0])

내림차순

intervals.sort(key=lambda x: x[0], reverse=True)

x[1] 인 end를 기준으로 정렬할 시 다음과 같이 될 수 있다.

cur : list내에서 현재 가리키고 있는 [start, end] 요소

next : 다음 [start, end] 요소

[Two Pointer] 392. Is Subsequence

삼월은마치 — Wed, 23 Oct 2024 22:26:32 +0900

https://leetcode.com/contest/leetcode-weekly-contest-3/problems/is-subsequence/

Given two strings s and t, return true if s is a subsequence of t, or false otherwise.

A subsequence of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., "ace" is a subsequence of "abcde" while "aec" is not).

Example 1:

Input: s = "abc", t = "ahbgdc"
Output: true

Example 2:

Input: s = "axc", t = "ahbgdc"
Output: false

Constraints:

0 <= s.length <= 100
0 <= t.length <= 104
s and t consist only of lowercase English letters.

class Solution:
    def isSubsequence(self, s: str, t: str) -> bool:
        #s를 split 후 t를 앞에서부터 순회하면서 찾다가 일치하면 다음 탐색 (대신 인덱스도 위치도 동일하게)
        
        i, j = 0, 0 #포인터 초기화
        
        while i < len(s) and j < len(t):
            if s[i] == t[j]:
                i += 1
            j += 1
                
        #true, false만 반환하므로 i가 전체 s의 길이와 동일할 때까지 증가하면 모두 찾았다는 의미
        return i == len(s) #True

while i < len(s) and j < len(t):

1. s의 길이가 남아있는 동안만 t를 순회하도록 1차로 걸 수 있는 조건

            if s[i] == t[j]:
                i += 1
            j += 1

2. 일치할 경우 둘다 인덱스 +1부터 시작하도록 거는 조건

‍ j 인덱스를 증가시키는 로직을 i의 증가 로직과 다른 들여쓰기 수준에서 진행하는 이유

1. i 인덱스 관리: i 인덱스는 문자열 s의 문자가 문자열 t에서 일치할 때만 증가한다. 문자열 s의 다음 문자를 찾기 위해 t에서 계속 탐색을 진행해야 함을 의미한다.

2. j 인덱스 관리: j는 문자열 t를 순회하는 인덱스로서, 문자열 t의 모든 문자를 확인하면서 s의 문자와 일치하는지 여부를 각 위치에서 검사하는데, j 인덱스의 증가는 조건과 무관하게 항상 일어나야 한다.

따라서 if 문의 외부에서 처리되어 t의 각 문자를 확인할 때마다 j가 무조건 1씩 증가해야 한다.

[stack] 20. Valid Parentheses

삼월은마치 — Wed, 23 Oct 2024 16:46:05 +0900

https://leetcode.com/problems/valid-parentheses/description/

Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

An input string is valid if:

Open brackets must be closed by the same type of brackets.
Open brackets must be closed in the correct order.
Every close bracket has a corresponding open bracket of the same type.

Example 1:

Input: s = "()"

Output: true

Example 2:

Input: s = "()[]{}"

Output: true

Example 3:

Input: s = "(]"

Output: false

Example 4:

Input: s = "([])"

Output: true

Constraints:

1 <= s.length <= 104
s consists of parentheses only '()[]{}'.

유효한 괄호로 이루어져있는지 판별하는 문제

class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        bracket_map = {')': '(', '}': '{', ']':'['}

        for brkt in s:
            if brkt in bracket_map.values(): # 열린 괄호(value)
                stack.append(brkt)

            elif brkt in bracket_map: #닫힌 괄호(key)
            # stack이 비어있거나
            #해당 닫힌 괄호를 key로 삼아 조회했을 때 기존 스택에 매칭되는 value(=열린괄호)가 없다면
                if not stack or stack.pop() != bracket_map[brkt]: 
                    return False
        
        return not stack #모든 괄호가 정상적으로 닫히면 스택이 비워지므로
        # not stack이 맞으면 True, 아니면 False

이렇게 짝을 지어서 dictionary로 저장해 두면 편하다니

  # 각 괄호의 짝을 딕셔너리로 표현
        bracket_map = {')': '(', '}': '{', ']': '['}

닫힌 괄호를 key로, 열린 괄호를 value로 사용하는 방법이다.

열린 괄호는 생길 때마다 push되고, 닫힌 괄호를 만날 때 pop을 하는데,

pop을 하는 순간에 stack에 닫힌 괄호 key의 타입에 맞는 열린 괄호가 존재하지 않는 경우 False를 반환한다.

elif char in bracket_map:
                # 스택이 비어있거나 스택의 마지막 원소와 짝이 맞지 않는 경우
                if not stack or stack.pop() != bracket_map[char]:
                    return False

출력은 True, False로 받아야 하므로, not stack에 대해 맞다면 True, 스택이 비워지지 않아 not stack이 아니라면 False

[String] 14. Longest Common Prefix / startswith() 함수

삼월은마치 — Wed, 23 Oct 2024 15:34:48 +0900

https://leetcode.com/problems/longest-common-prefix/description/

Write a function to find the longest common prefix string amongst an array of strings.

If there is no common prefix, return an empty string "".

Example 1:

Input: strs = ["flower","flow","flight"]
Output: "fl"

Example 2:

Input: strs = ["dog","racecar","car"]
Output: ""
Explanation: There is no common prefix among the input strings.

Constraints:

1 <= strs.length <= 200
0 <= strs[i].length <= 200
strs[i] consists of only lowercase English letters.

startswith()

접두어, 접미어를 파악하기 위해 파이썬에서 제공되는 startwith(), endwith()를 사용할 수 있다.

다음의 함수를 사용할 경우 접두(미)어를 쉽게 찾을 수 있으며 dictionary 타입에서도 사용 가능

예시

sentence = "girl's generation"

result = sentence.startswith('girl')
print(result)

# 출력결과: True

endswith()

idol = [
    "girl's generation",
    "black pink",
    "A-pink",
    "aespa"
]

for i in idol:
    # 문자열을 소문자로 변환한 후, 'pink'로 끝나는지 확인
    if i.lower().endswith('pink'):
        print(i)  # 문자열 출력
    else:
        print("")  # 빈 문자열 출력
        
#출력결과
#black pink
#A-pink

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        if not strs:
            return "" #빈 리스트 입력 시 빈 문자열 반환
        
        short_str = min(strs, key=len) # 사전순이 아닌 문자열 길이로 최소값 찾기
        for i in range(len(short_str)): # 가장 짧은 문자열 기준으로
            for s in strs: # 기존 strs 리스트 내 요소들과 비교
                if s[i] != short_str[i]: # 더이상 일치하는 문자가 없으면
                    return short_str[:i] # i-1번째까지 문자열 출력
        
        return short_str #모든 문자열이 공통 접두어일 경우

for문으로 문자열을 하나하나 돌면서 비교하거나 "가장 짧은 문자열"로 비교하면 효율적이다.

+) 빈 문자열이 입력으로 주어진 경우에도 ""로 처리해야 한다고 한다.

그냥 공통 접두사어가 없으면 ""로 반환하는 것만 생각했었기에 처음엔 떠오르지 않았다.

가장 짧은 문자열을 기준으로 비교하므로, strs 리스트 내의 요소 s도 인덱스를 i까지만 돌면 된다.

앞에서부터 i-1번째까지 출력하면 접두어를 뽑아낼 수 있다.

*슬라이스 범위

start: 슬라이스의 시작 인덱스 (포함).
- 생략하면 0으로 간주
end: 슬라이스의 종료 인덱스 (미포함).
- 인덱스 end에 해당하는 문자는 포함되지 않음
step: 문자열을 몇 칸씩 건너뛸지를 지정합니다. 기본값은 1

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        if not strs:
            return "" #빈 리스트 입력 시 빈 문자열 반환
        
        short_str = min(strs, key=len) # 사전순이 아닌 문자열 길이로 최소값 찾기
        for i in range(len(short_str)): # 가장 짧은 문자열 기준으로
            for s in strs: # 기존 strs 리스트 내 요소들과 비교
                if s[i] != short_str[i]: # 더이상 일치하는 문자가 없으면
                    return short_str[:i] # i-1번째까지 문자열 출력

여기까지만 구현했을 경우, 가장 짧은 문자열이 다른 문자열들과 비교했을 때 전체가 공통 접두어가 될 경우에 대한 결과가 빠져있으므로 short_str 자체를 리턴하는 부분도 넣어야 한다.

‍ ["dog","racecar","car"] 처럼 공통접두어가 존재하지 않는 경우에 대한 처리는 어디서?

for i in range(len(short_str)): # 가장 짧은 문자열 기준으로
            for s in strs: # 기존 strs 리스트 내 요소들과 비교
                if s[i] != short_str[i]: # 더이상 일치하는 문자가 없으면
                    return short_str[:i] # i-1번째까지 문자열 출력

해당 for문 안에서 슬라이싱 문법으로 i-1번째까지 출력이므로, 공통 접두어가 없을 경우 자연스럽게 끝나고 "" 빈 문자열을 반환하게 된다.

[String] 412. Fizz Buzz

삼월은마치 — Wed, 23 Oct 2024 14:14:43 +0900

https://leetcode.com/problems/fizz-buzz/description/

Given an integer n, return a string array answer (1-indexed) where:

answer[i] == "FizzBuzz" if i is divisible by 3 and 5.
answer[i] == "Fizz" if i is divisible by 3.
answer[i] == "Buzz" if i is divisible by 5.
answer[i] == i (as a string) if none of the above conditions are true.

1부터 n까지의 숫자를 순서대로 출력합니다.
각 숫자에 대해 다음 규칙을 따릅니다:
- 숫자가 3의 배수일 경우: "Fizz" 출력
- 숫자가 5의 배수일 경우: "Buzz" 출력
- 숫자가 3과 5의 공배수(15의 배수)일 경우: "FizzBuzz" 출력
- 위 조건에 해당하지 않는 숫자일 경우: 숫자 그대로 출력

3,6,9게임이 떠오르는 문제

수가 3, 6, 9가 들어가면 박수를 치고 33이면 박수를 두 번 쳐야 하니까

class Solution:
    def fizzBuzz(self, n: int) -> List[str]:
        result = []
        for i in range(1, n+1):
            if i % 15 == 0:
                result.append("FizzBuzz")
            elif i % 5 == 0:
                result.append("Buzz")
            elif i % 3 == 0:
                result.append("Fizz")
            else:
                result.append(str(i)) # int -> str
        
        return result

빈 리스트 result [] 를 만들고 for문을 돌면서 하나하나 추가해 주면 된다.

+) 이건 그냥 리트코드 세팅보다가 파이썬 문법이 신기해서 참고용

[math] 7. Reverse Integer

삼월은마치 — Wed, 23 Oct 2024 13:53:08 +0900

https://leetcode.com/problems/reverse-integer/description/

Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes the value to go outside the signed 32-bit integer range [-231, 231 - 1], then return 0.

Assume the environment does not allow you to store 64-bit integers (signed or unsigned).

Example 1:

Input: x = 123
Output: 321

Example 2:

Input: x = -123
Output: -321

Example 3:

Input: x = 120
Output: 21

Constraints:

-231 <= x <= 231 - 1

풀이

class Solution:
    def reverse(self, x: int) -> int:
        
        sign = -1 if x < 0 else 1
        
        reverse_num = str(abs(x))[::-1]
        
        result = sign * int(reverse_num)

        if result < -2**31 or 2**31 < result:
            return 0

        return result

https://marchislike.tistory.com/248

⬆️앞서 적용했던 슬라이싱 방법을 사용하면 간단할 것 같은데,

문제는 example3을 보았을 때, 변환한 뒤 앞자리에 0이 존재한다면 0을 제거해야 하는 점이다.

그런데 찾아보니 파이썬에서 문자열을 int형으로 변환하면 자동으로 0이 제거된다고 한다..!

그래서 처음에 무지성으로 이렇게 구현을 해서 돌렸다가..

class Solution:
    def reverse(self, x: int) -> int:
        return int(str(x)[::-1])

오히려 음수일 경우 부호 처리에 대한 부분을 빼먹었다.

-123을 입력하면 321- 가 아니라 -321이 나와야 한다.

그래서 reverse num을 저장한 후 해당 reverse num에 대해 다시 부호를 처리해 줘야 한다.

sign = -1 if x < 0 else 1

x가 음수라면 sign = -1 을 넣어줘서 나중에 reverse_num에 곱해서 음수로 만들어준다.

값은 절대값으로 받아야겠다.

int x에 대해 절대값 abs()으로 받은 후 str으로 형변환하여 슬라이싱을 사용할 수 있도록 한다.

reverse_num = str(abs(x))[::-1]

최종 값에 대해 다시 int형으로 변환한다.

result = sign * int(reverse_num)

마지막으로 정수 범위 지정에 대한 리턴값도 처리해야 한다.

>> If reversing x causes the value to go outside the signed 32-bit integer range [-231, 231 - 1], then return 0.

if result < -2**31 or 2**31 < result:
	return 0

[math] 9. Palindrome-number

삼월은마치 — Wed, 23 Oct 2024 12:49:38 +0900

https://leetcode.com/problems/palindrome-number/description/

Given an integer x, return true if x is a palindrome, and false otherwise.

Example 1:

Input: x = 121
Output: true
Explanation: 121 reads as 121 from left to right and from right to left.

Example 2:

Input: x = -121
Output: false
Explanation: From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome.

Example 3:

Input: x = 10
Output: false
Explanation: Reads 01 from right to left. Therefore it is not a palindrome.

Constraints:

-231 <= x <= 231 - 1

Solution

class Solution:
    def isPalindrome(self, x: int) -> bool:
        return False if x < 0 else x == int(str(x)[::-1])

처음에 한 자리수일 때는 true, 두 자리면 같아야만 true, 이후 mid를 기준으로 left/right 자르는 방법을 생각했는데

더 간단한 방법이 있었다.

슬라이싱[::]을 사용해서 기존 x 값과 reverse값이 같은지 비교하면 됐다.

슬라이싱은 [start:end:step] 순서로, step에 -1을 넣으면 역순으로 str을 변환하니 유용하다.

*슬라이싱을 적용할 수 있는 자료형은 아래와 같이 "순서가 존재하는 연속된 시퀀스형만" 가능하다.

문자열 (str)
리스트 (list)
튜플 (tuple)
범위 (range)

따라서 int형으로 주어진 x에 대해 str으로 적용한 다음 다시 int 형변환이 필요하다.

int(str(x)[::-1])

reference

https://oneteveryday.tistory.com/224

[hash] 1. two-sum

삼월은마치 — Wed, 23 Oct 2024 11:13:36 +0900

https://leetcode.com/problems/two-sum/

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Example 1:

Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].

Example 2:

Input: nums = [3,2,4], target = 6
Output: [1,2]

Example 3:

Input: nums = [3,3], target = 6
Output: [0,1]

class Solution:
    def twoSum(self, nums, target):
        num_dict = {}  # 해시 테이블 초기화

        for i, num in enumerate(nums):  # 인덱스와 값을 동시에 얻음
            comp = target - num  # 보수 계산 (complement)
            
            if comp in num_dict:  # 보수가 해시 테이블에 있는지 확인
                return [num_dict[comp], i]  # 보수와 현재 숫자의 인덱스를 반환
            
            num_dict[num] = i  # 현재 숫자와 인덱스를 해시 테이블에 저장

        return []  # 해결할 수 없는 경우 빈 리스트 반환

‍ return [num_dict[comp], i]

보수 comp가 해시테이블 num_dict 안에 존재한다면, 리스트[]를 리턴하는데, 두 가지를 반환한다.

num_dict[comp]와 i 이다.

num_dict[comp]는 target에서 i번째 인덱스의 값에 해당하는 요소를 뺀 값을 지닌다.

혹여 해당하는 수 조합이 없다면 마지막 return은 [] 빈 리스트로 받는다.

if comp in num_dict:
    return [num_dict[comp], i]

**comp(보수)**가 해시 테이블(num_dict)에 존재하는지 확인. 있다면, 해당 보수의 인덱스와 현재 인덱스 i를 리스트로 반환

예를 들어, 주어진 배열이 [2, 7, 11, 15]이고 target이 9일 때:

첫 번째 숫자 2에서 보수는 9 - 2 = 7 이다.
두 번째 숫자 7을 만났을 때, comp(보수)인 2가 이미 해시 테이블에 존재한다.
- 이때 해시 테이블에 저장된 2의 인덱스는 0이다.
따라서 [0, 1]을 반환한다.

nums = [2, 7, 11, 15]
target = 9
numMap = {2: 0, 7: 1}  # 딕셔너리 상태

complement = 2  # target - nums[i] = 9 - 7 = 2
print(numMap[complement])  # 출력: 0

numMap[complement] = 0  # 보수의 인덱스
i = 1  # 현재 숫자의 인덱스

print([numMap[complement], i])  # 출력: [0, 1]

*출력결과

nums = [2,7,11,15] / target = 9

Index: 0, Value: 2
Index: 1, Value: 7
Index: 2, Value: 11
Index: 3, Value: 15

❗해시에서는 값이 키로 작용하므로, 이 값(숫자)으로 접근하여 인덱스를 반환할 수 있다.

num_dict[2] = 0  # 숫자 2의 인덱스는 0
print(num_dict[2])  # 출력: 0

[PintOS] WIL (4) 난 이해를 한 걸까..?

삼월은마치 — Tue, 22 Oct 2024 00:09:25 +0900

이 글은 swap disk와 copy on write에 대해 무지성으로 작성되었습니다.

Copy On Write

현재까지는 fork할 때 메모리가 할당된 page에 대해서 부모에서 자식으로 복사할 때 같은 내용의 물리메모리를 자식에게도 할당 해주었다. 같은 메모리가 두 번 복사되기에 메모리 낭비로 볼 수도 있다.

cow는 fork시에는 부모와 자식이 동일한 물리 메모리를 가리키게 하고

해당 페이지에 write 요청이 발생해야 새로운 물리메모리를 할당해 주도록 수정한다.

fork 시 물리메모리를 모두 복사하지 않고 부모와 같은 물리메모리를 공유하다가 write작업 시 해당 페이지의 물리메모리를 새로 맵핑한다.

부모와 자식 프로세스는 쓰기 작업 이후에 서로 다른 메모리 프레임을 가지게 되어, 쓰기 작업이 서로에게 영향을 주지 않

** 페이지를 만들 때부터 쓰려고 하면 page fault가 나도록 해야 함

여기부터는 수정이 있었던 파일 일부에 대해 간략히 메모하고 지나가겠다.

1. thread.h 수정

#ifdef VM
    /* Table for whole virtual memory owned by thread. */
    struct supplemental_page_table spt;
    void *rsp;
    void* stack_bottom;
#endif

각 스레드마다 보조 페이지 테이블(supplemental_page_table)을 추가하여 가상 메모리를 관리
rsp는 현재 스레드의 스택 포인터를 저장하며, 커널 모드와 유저 모드 전환 시 사용
stack_bottom은 현재 스레드의 스택의 바닥 주소를 나타내며, 스택 확장 시 사용

2. anon.h

#ifndef VM_ANON_H
#define VM_ANON_H
#include "vm/vm.h"

#define SECTOR_SIZE 512 // 추가된 부분

struct page;
enum vm_type;

struct anon_page {
    int bit_idx; // 추가된 부분: 스왑 공간에서의 비트맵 인덱스를 저장
};

void vm_anon_init (void);

SECTOR_SIZE를 정의하여 디스크 섹터의 크기를 지정
anon_page 구조체에 bit_idx를 추가하여 페이지가 스왑 디스크의 어느 위치에 저장되었는지 추적
이는 스왑 인/아웃 시 해당 페이지의 위치를 알아내기 위해 필요

3. file.h

enum vm_type;

struct file_page {
    struct file *file;
    off_t ofs;
    void *file_start_page;
    void *file_end_page;
    size_t page_read_bytes;
    size_t page_zero_bytes;
};

void vm_file_init (void);

file_page 구조체를 정의하여 파일 기반 페이지에 필요한 정보를 저장

file: 해당 페이지가 속한 파일을 가리킨다.
ofs: 파일 내에서의 오프셋
file_start_page, file_end_page: 메모리 매핑된 파일의 시작과 끝 페이지 주소
page_read_bytes: 페이지에서 읽어야 할 바이트 수
page_zero_bytes: 페이지에서 0으로 채워야 할 바이트 수

4. vm.h (1)

struct frame {
    void *kva;
    struct page *page;
    struct list_elem frame_elem; // 추가된 부분: 프레임 테이블 관리를 위한 리스트 요소
};

struct page {
    struct frame *frame;   /* Back reference for frame */

    /* Your implementation */
    struct hash_elem page_elem; /* 해시 테이블 요소 */
    bool is_writable;
    int bit_idx; // 스왑 비트맵 인덱스

    union {
        struct uninit_page uninit;
        struct anon_page anon;
        struct file_page file;
    #ifdef EFILESYS
        struct page_cache page_cache;
    #endif
    };
};

frame 구조체에 frame_elem을 추가하여 프레임 테이블을 리스트로 관리
page 구조체에 page_elem을 추가하여 보조 페이지 테이블에서 페이지를 해시 테이블로 관리
is_writable: 페이지의 쓰기 가능 여부를 나타냄
bit_idx: 스왑 공간에서의 인덱스를 저장하여 스왑 인/아웃 시 사용

5. vm.h(2)

// for aux
struct load_info{
    struct file *file;
    size_t page_read_bytes;
    size_t page_zero_bytes;
    off_t ofs;
    bool writable;
    size_t file_start_page;
    size_t file_end_page;
};

load_info 구조체를 정의하여 지연 로딩(lazy loading) 시 필요한 정보를 저장
aux로 전달되어 페이지를 초기화할 때 사용

6. process.c (1)

int process_wait(tid_t child_tid UNUSED)
{
    struct thread *child = get_child_process(child_tid);
    if (child == NULL)
        return -1;

    sema_down(&child->wait_sema);
    list_remove(&child->child_elem);
    int result = child->exit_status;
    sema_up(&child->exit_sema);

    return result; // 변경된 부분: result를 반환
}

process_wait 함수에서 child->exit_status 대신 result 변수를 반환하도록 수정
이는 child->exit_status가 sema_up 이후에 변경될 수 있으므로, 미리 값을 저장해 두기 위함

7. process.c (2)

void process_exit(void)
{
    struct thread *cur = thread_current();

    // FDT의 모든 파일을 닫는다.
    for (int i = 2; i < FDT_COUNT_LIMIT; i++) {
        process_close_file(i);
    }
    palloc_free_multiple(cur->fdt, FDT_PAGES);

    // 현재 실행 중인 파일도 닫는다.
    file_close(cur->running); 
    process_cleanup();

    // 부모에게 종료를 알린다.
    sema_up(&cur->wait_sema);

    // 부모의 signal을 기다린다.
    sema_down(&cur->exit_sema);

    // 추가된 부분: 보조 페이지 테이블 해시 제거
    hash_destroy(&cur->spt.pages, page_dealloc);
}

프로세스가 종료될 때 보조 페이지 테이블을 제거하여 메모리 누수를 방지
hash_destroy와 page_dealloc을 사용하여 페이지를 해제

8. lazy_load_segment에서 file seek 추가 및 aux 사용

struct load_info *info = (struct load_info *)aux;
uint8_t *kpage = page->frame->kva;

file_seek(info->file, info->ofs);
if (file_read(info->file, kpage, info->page_read_bytes) != (int)info->page_read_bytes){
    palloc_free_page(kpage);
    free(aux);
    return false;
}
memset(kpage + info->page_read_bytes, 0, info->page_zero_bytes);

free(aux);

return true;

lazy_load_segment 함수에서 file_seek을 사용하여 파일의 정확한 위치에서 읽음
aux로 전달된 load_info 구조체를 사용하여 필요한 정보를 가져옴
페이지를 메모리에 로드한 후 aux를 해제

9. load_segment 함수 수정

bool load_segment(struct file *file, off_t ofs, uint8_t *upage,
                 uint32_t read_bytes, uint32_t zero_bytes, bool writable)
{
    ASSERT((read_bytes + zero_bytes) % PGSIZE == 0);
    ASSERT(pg_ofs(upage) == 0);
    ASSERT(ofs % PGSIZE == 0);

    file_seek (file, ofs);
    while (read_bytes > 0 || zero_bytes > 0)
    {
        size_t page_read_bytes = read_bytes < PGSIZE ? read_bytes : PGSIZE;
        size_t page_zero_bytes = PGSIZE - page_read_bytes;

        struct load_info *aux = (struct load_info  *)malloc(sizeof(struct load_info));
        if(aux == NULL)	
            return false;
        memset(aux, 0, sizeof(struct load_info));
        aux->file = file;
        aux->page_read_bytes = page_read_bytes;
        aux->page_zero_bytes = page_zero_bytes;
        aux->writable = writable;
        aux->ofs = ofs;

        if (!vm_alloc_page_with_initializer(VM_ANON, upage, writable, lazy_load_segment, aux))
            return false;

        read_bytes -= page_read_bytes;
        zero_bytes -= page_zero_bytes;
        upage += PGSIZE;
        ofs += page_read_bytes;
    }
    return true;
}

aux로 load_info 구조체를 만들어 지연 로딩에 필요한 정보를 전달
file_seek을 통해 파일의 오프셋을 설정
vm_alloc_page_with_initializer를 사용하여 페이지를 할당하고 초기화

10. setup_stack 함수 수정

static bool setup_stack(struct intr_frame *if_)
{
    bool success = false;
    void *stack_bottom = (void *)(((uint8_t *)USER_STACK) - PGSIZE);

    if(vm_alloc_page(VM_ANON | VM_MARKER_0, stack_bottom, 1)){
        success = vm_claim_page(stack_bottom);
        if(success){
            if_->rsp = USER_STACK;
            thread_current()->stack_bottom = stack_bottom;
        }
    }
    return success;
}

스택을 초기화할 때 페이지를 할당하고 즉시 클레임(claim)
stack_bottom을 thread_current()에 저장하여 이후 스택 확장 시 사용
유저 스택의 최상단 주소를 if_->rsp에 설정

11. anon.c에서 swap in/out 구현

static bool anon_swap_in (struct page *page, void *kva) {
    struct anon_page *anon_page = &page->anon;
    
    int idx = anon_page->bit_idx;
    if(idx < 0) {
        return false;
    }
    
    for (int i = 0; i < 8; i++) {
        disk_sector_t sec_no = (disk_sector_t) idx*8 + i;
        disk_read(swap_disk, sec_no, kva + SECTOR_SIZE * i);
    }

    anon_page->bit_idx = -1;
    bitmap_flip(swap_table.swap_used_map, idx);

    return true;
}

static bool anon_swap_out (struct page *page) {
    struct anon_page *anon_page = &page->anon;
    struct frame *victim_frame = page->frame;
    int idx = bitmap_scan(swap_table.swap_used_map, 0, 1, false);
    if (idx == BITMAP_ERROR) {
        return false;
    }

    for (int i = 0; i < 8; i++) {
        disk_sector_t sec_no = (disk_sector_t) idx*8 + i;
        disk_write(swap_disk, sec_no, (victim_frame->kva) + SECTOR_SIZE * i);
    }

    anon_page->bit_idx = idx;
    pml4_clear_page(thread_current()->pml4, page->va);
    bitmap_flip(swap_table.swap_used_map, idx);

    return true;
}

static void anon_destroy (struct page *page) {
    struct anon_page *anon_page = &page->anon;
    struct thread *cur = thread_current();
    hash_delete(&cur->spt.pages, &page->page_elem);
    if (page->frame){
        pml4_clear_page(cur->pml4, page->va);
        palloc_free_page(page->frame->kva); 
        list_remove(&page->frame->frame_elem);
        free(page->frame);
        page->frame = NULL;
    }
}

anon_swap_in: 스왑 디스크에서 페이지를 메모리로 읽어오기
- 스왑 공간에서 bit_idx를 사용하여 위치를 찾기
- 8개의 섹터를 읽어와 페이지 크기(4KB)를 채우기
- 스왑 비트맵을 업데이트
anon_swap_out: 메모리의 페이지를 스왑 디스크로 내보내기
- 스왑 비트맵에서 빈 공간을 찾기
- 8개의 섹터에 페이지를 기록
- 페이지 테이블 엔트리를 제거
anon_destroy: 페이지를 해제하고 관련 자원을 정리

12. file.c에서 파일 기반 페이지의 swap in/out 구현

bool file_backed_initializer (struct page *page, enum vm_type type, void *kva) {
    page->operations = &file_ops;
    struct file_page *file_page = &page->file;
    return true;
}

static bool file_backed_swap_in (struct page *page, void *kva) {
    struct file_page *file_page = &page->file;
    struct file *file = file_page->file;
    file_seek(file, file_page->ofs);
    file_read_at(file, kva, file_page->page_read_bytes, file_page->ofs);
    return true;
}

static bool file_backed_swap_out (struct page *page) {
    uint64_t *pml4 = thread_current()->pml4;
    struct file_page *file_page = &page->file;

    if(pml4_is_dirty(pml4, page->va)){
        struct file *file = file_page->file;
        file_seek(file, file_page->ofs);
        file_write_at(file, page->frame->kva, file_page->page_read_bytes, file_page->ofs);
        pml4_set_dirty(pml4, page->va, false);
    }

    pml4_clear_page(pml4, page->va);

    return true;
}

static void file_backed_destroy (struct page *page) {
    struct file_page *file_page = &page->file;
    uint64_t *pml4 = thread_current()->pml4;
    struct supplemental_page_table *spt = &thread_current()->spt;

    hash_delete(&spt->pages, &page->page_elem);

    if(page->frame != NULL){
        if(pml4_is_dirty(pml4, page->va))
            file_write_at(file_page->file, page->va, file_page->page_read_bytes, file_page->ofs);
        
        pml4_clear_page(pml4, page->va);
        palloc_free_page(page->frame->kva);

        list_remove(&page->frame->frame_elem);
        free(page->frame);
        page->frame = NULL;
    }
}

file_backed_swap_in: 파일에서 페이지를 읽어와 메모리에 로드
file_backed_swap_out: 페이지가 수정되었는지 확인하고, 수정되었으면 파일에 내용을 기록
file_backed_destroy: 페이지를 해제하고, 수정된 내용이 있으면 파일에 반영

vm.c 코드 (전체코드)

/* vm.c: Generic interface for virtual memory objects. */

#include "threads/malloc.h"
#include "vm/vm.h"
#include "vm/inspect.h"
#include "threads/mmu.h"
#include "userprog/process.h"
#include "userprog/syscall.h"
#include <string.h>

static unsigned
page_hash (const struct hash_elem *p_, void *aux UNUSED);
static bool
page_less (const struct hash_elem *a_,
           const struct hash_elem *b_, void *aux UNUSED);

static struct page *page_lookup (struct supplemental_page_table *spt, const void *address);

struct list frame_table;

struct lock frame_table_lock;

/* Initializes the virtual memory subsystem by invoking each subsystem's
 * intialize codes. */
void
vm_init (void) {
	vm_anon_init ();
	vm_file_init ();
	list_init(&frame_table);

	lock_init(&frame_table_lock);
#ifdef EFILESYS  /* For project 4 */
	pagecache_init ();
#endif
	register_inspect_intr ();
	/* DO NOT MODIFY UPPER LINES. */
	/* TODO: Your code goes here. */
}

/* Get the type of the page. This function is useful if you want to know the
 * type of the page after it will be initialized.
 * This function is fully implemented now. */
enum vm_type
page_get_type (struct page *page) {
	int ty = VM_TYPE (page->operations->type);
	switch (ty) {
		case VM_UNINIT:
			return VM_TYPE (page->uninit.type);
		default:
			return ty;
	}
}

/* Helpers */
static struct frame *vm_get_victim (void);
static bool vm_do_claim_page (struct page *page);
static struct frame *vm_evict_frame (void);

/* Create the pending page object with initializer. If you want to create a
 * page, do not create it directly and make it through this function or
 * `vm_alloc_page`. */
bool
vm_alloc_page_with_initializer (enum vm_type type, void *upage, bool writable,
		vm_initializer *init, void *aux) {
	ASSERT (VM_TYPE(type) != VM_UNINIT)

	struct supplemental_page_table *spt = &thread_current ()->spt;

	struct page* page = spt_find_page (spt, upage);

	/* Check wheter the upage is already occupied or not. */
	if (page == NULL) {
		/* TODO: Create the page, fetch the initialier according to the VM type,
		 * TODO: and then create "uninit" page struct by calling uninit_new. You
		 * TODO: should modify the field after calling the uninit_new. */
		page = malloc(sizeof(struct page));
		if (page == NULL)
			goto err;
		bool (*initializer)(struct page *, enum vm_type, void *);
		switch (VM_TYPE(type)){
		case VM_ANON:
			initializer = anon_initializer;
			break;
		case VM_FILE:
			initializer = file_backed_initializer;
			break;
		default:
			goto err;
		}

		uninit_new(page, upage, init, type, aux, initializer);
		page->is_writable = writable;
		
		/* TODO: Insert the page into the spt. */
		return spt_insert_page(spt, page);
	}
err:
	return false;
}

/* Find VA from spt and return page. On error, return NULL. */
struct page *
spt_find_page (struct supplemental_page_table *spt UNUSED, void *va UNUSED) {
	struct page *page = NULL;
	/* TODO: Fill this function. */
	return page_lookup(spt, va);
}

/* Insert PAGE into spt with validation. */
bool
spt_insert_page (struct supplemental_page_table *spt UNUSED,
		struct page *page UNUSED) {
	int succ = false;
	/* TODO: Fill this function. */
	struct hash_elem * result = hash_insert(&spt->pages, &page->page_elem);
	if(result == NULL)
		succ = true;
	return succ;
}

void
spt_remove_page (struct supplemental_page_table *spt, struct page *page) {
	vm_dealloc_page (page);
	return true;
}

/* Get the struct frame, that will be evicted. */
static struct frame *
vm_get_victim (void) {
	 /* TODO: The policy for eviction is up to you. */
	struct list_elem *e = list_pop_front(&frame_table);
	struct frame *victim = list_entry(e, struct frame, frame_elem);

	return victim;
}

/* Evict one page and return the corresponding frame.
 * Return NULL on error.*/
static struct frame *
vm_evict_frame (void) {
	struct frame *victim = vm_get_victim ();
	/* TODO: swap out the victim and return the evicted frame. */
	struct page *victim_page = victim->page;
	
	if(swap_out(victim_page)) {

		victim_page->frame = NULL;
		victim->page = NULL;
		memset(victim->kva, 0, PGSIZE);

		return victim;
	}

	return NULL;
}

/* palloc() and get frame. If there is no available page, evict the page
 * and return it. This always return valid address. That is, if the user pool
 * memory is full, this function evicts the frame to get the available memory
 * space.*/
static struct frame *
vm_get_frame (void) {
	struct frame *frame = (struct frame*)malloc(sizeof(struct frame));
	ASSERT (frame != NULL);
	/* TODO: Fill this function. */
	frame->kva = palloc_get_page(PAL_USER);
	frame->page = NULL;
	if(frame->kva == NULL) {
		free(frame);
		frame = vm_evict_frame();
	}
	
	ASSERT (frame->page == NULL);
	
	lock_acquire(&frame_table_lock);
	list_push_back(&frame_table, &frame->frame_elem);
	lock_release(&frame_table_lock);

	return frame;
}

/* Growing the stack. */
static void
vm_stack_growth (void *addr UNUSED) {
    if(vm_alloc_page(VM_ANON | VM_MARKER_0, pg_round_down(addr), 1))
		thread_current()->stack_bottom -= PGSIZE;
	
}

/* Handle the fault on write_protected page */
static bool
vm_handle_wp (struct page *page UNUSED) {
}

/* Return true on success */
bool
vm_try_handle_fault (struct intr_frame *f, void *addr,
		bool user, bool write, bool not_present) {
	struct supplemental_page_table *spt = &thread_current ()->spt;
	/* TODO: Validate the fault */
	if(addr == NULL || is_kernel_vaddr(addr)){
		return false;
	}
	
	if (!not_present){
		return false;
	}

	void *rsp = f->rsp; // user access인 경우 rsp는 유저 stack을 가리킨다.
    if (!user) // kernel access인 경우 thread에서 rsp를 가져와야 한다.
		rsp = thread_current()->rsp;

	// 스택 확장으로 처리할 수 있는 폴트인 경우, vm_stack_growth를 호출한다.
    if (rsp-8 <= addr  && USER_STACK - 0x100000 <= addr && addr <= USER_STACK)
		vm_stack_growth(pg_round_down(addr));
	
	struct page *page = spt_find_page(spt, addr);
	if (page == NULL){
		return false;
	}
	if (write && !page->is_writable){
		return false;
	}
	
	/* TODO: Your code goes here */
	bool success = vm_do_claim_page (page);
	return success;
}

/* Free the page.
 * DO NOT MODIFY THIS FUNCTION. */
void
vm_dealloc_page (struct page *page) {
	destroy (page);
	free (page);
}

/* Claim the page that allocate on VA. */
bool
vm_claim_page (void *va UNUSED) {
	struct thread *cur = thread_current();
	struct page *page = spt_find_page(&cur->spt, va);
	/* TODO: Fill this function */
	if (page == NULL){
		return false;
	}
	return vm_do_claim_page (page);
}

/* Claim the PAGE and set up the mmu. */
static bool
vm_do_claim_page (struct page *page) {
	struct frame *frame = vm_get_frame ();

	/* Set links */
	frame->page = page;
	page->frame = frame;

	/* TODO: Insert page table entry to map page's VA to frame's PA. */

	struct thread *cur = thread_current();
	pml4_set_page(cur->pml4, page->va, frame->kva, page->is_writable);
	return swap_in(page, frame->kva);
}

/* Initialize new supplemental page table */
void
supplemental_page_table_init (struct supplemental_page_table *spt UNUSED) {
	hash_init (&spt->pages, page_hash, page_less, NULL);
}

/* Returns a hash value for page p. */
unsigned
page_hash (const struct hash_elem *p_, void *aux UNUSED) {
  const struct page *p = hash_entry (p_, struct page, page_elem);
  return hash_bytes (&p->va, sizeof p->va);
}

/* Returns true if page a precedes page b. */
bool
page_less (const struct hash_elem *a_,
           const struct hash_elem *b_, void *aux UNUSED) {
  const struct page *a = hash_entry (a_, struct page, page_elem);
  const struct page *b = hash_entry (b_, struct page, page_elem);

  return a->va < b->va;
}

/* Returns the page containing the given virtual address, or a null pointer if no such page exists. */
struct page *
page_lookup (struct supplemental_page_table *spt, const void *va) {
	struct page p;
	struct hash_elem *e;
	
	p.va = pg_round_down(va);
	e = hash_find (&spt->pages, &p.page_elem);
	return e != NULL ? hash_entry (e, struct page, page_elem) : NULL;
}

/* Copy supplemental page table from src to dst */
bool
supplemental_page_table_copy (struct supplemental_page_table *dst,
		struct supplemental_page_table *src) {
	struct hash_iterator i;
	struct hash_elem *elem;
	hash_first(&i, &src->pages);
	while ((elem = hash_next(&i))){
		struct page *p = hash_entry(elem, struct page, page_elem);
		enum vm_type type = page_get_type(p);

		if (VM_TYPE(p->operations->type) == VM_UNINIT){
			//if(!vm_alloc_page_with_initializer(VM_ANON, p->va, p->is_writable, p->uninit.init, p->uninit.aux)) // 왜 ANON?
			struct load_info *copy_aux = (struct load_info *)malloc(sizeof(struct load_info));
			memcpy(copy_aux, p->uninit.aux, sizeof(struct load_info));
			if(!vm_alloc_page_with_initializer(type, p->va, p->is_writable, p->uninit.init, copy_aux))
				return false;
		}else{
			if(vm_alloc_page(type, p->va, p->is_writable)
			&& vm_claim_page(p->va)){
				struct page* copy = spt_find_page(dst, p->va);
				memcpy(copy->frame->kva, p->frame->kva, PGSIZE);
				copy->frame->page = copy;
			}else
				return false;
		}
		
	}
	return true;
	
}

/* Free the resource hold by the supplemental page table */
void
supplemental_page_table_kill (struct supplemental_page_table *spt UNUSED) {
	/* TODO: Destroy all the supplemental_page_table hold by thread and
	* TODO: writeback all the modified contents to the storage. */
	// hash_destroy(&spt->pages, page_dealloc);
	hash_clear(&spt->pages, page_dealloc);
}

void page_dealloc(struct hash_elem *e, void *aux UNUSED) {
	struct page *target = hash_entry (e, struct page, page_elem);
	destroy(target);
    free(target);
}

핀토스의 vm.c 파일은 가상 메모리 객체에 대한 일반적인 인터페이스를 구현한다.

이 코드는 주로 가상 메모리의 초기화, 페이지 할당, 페이지 타입 확인, 페이지 테이블 관리, 페이지 폴트 처리, 스왑 인/아웃, 스택 확장 등의 기능을 포함한다.

1.초기화 함수 (vm_init):

가상 메모리 서브시스템 초기화를 담당한다.
vm_anon_init(), vm_file_init() 등 서브시스템 초기화를 호출하고, 프레임 테이블을 초기화하며, 락을 설정한다.

void
vm_init (void) {
	vm_anon_init ();
	vm_file_init ();
	list_init(&frame_table);

	lock_init(&frame_table_lock);
#ifdef EFILESYS  /* For project 4 */
	pagecache_init ();
#endif
	register_inspect_intr ();
	/* DO NOT MODIFY UPPER LINES. */
	/* TODO: Your code goes here. */
}

2. 페이지 타입 가져오기 (page_get_type):

페이지의 타입을 확인하는 함수로, 페이지가 어떤 타입(익명 페이지, 파일 백업 페이지 등)인지 반환한다.

enum vm_type
page_get_type (struct page *page) {
	int ty = VM_TYPE (page->operations->type);
	switch (ty) {
		case VM_UNINIT:
			return VM_TYPE (page->uninit.type);
		default:
			return ty;
	}
}

3. 페이지 할당 (vm_alloc_page_with_initializer):

새 페이지 객체를 생성하고 초기화 함수를 설정한다.
이미 존재하는 주소에 대한 페이지 요청이 들어오면, 해당 주소가 이미 사용 중인지 확인 후 새 페이지를 할당하거나 에러 처리한다.

bool
vm_alloc_page_with_initializer (enum vm_type type, void *upage, bool writable,
		vm_initializer *init, void *aux) {
	ASSERT (VM_TYPE(type) != VM_UNINIT)

	struct supplemental_page_table *spt = &thread_current ()->spt;

	struct page* page = spt_find_page (spt, upage);

	/* Check wheter the upage is already occupied or not. */
	if (page == NULL) {
		/* TODO: Create the page, fetch the initialier according to the VM type,
		 * TODO: and then create "uninit" page struct by calling uninit_new. You
		 * TODO: should modify the field after calling the uninit_new. */
		page = malloc(sizeof(struct page));
		if (page == NULL)
			goto err;
		bool (*initializer)(struct page *, enum vm_type, void *);
		switch (VM_TYPE(type)){
		case VM_ANON:
			initializer = anon_initializer;
			break;
		case VM_FILE:
			initializer = file_backed_initializer;
			break;
		default:
			goto err;
		}

		uninit_new(page, upage, init, type, aux, initializer);
		page->is_writable = writable;
		
		/* TODO: Insert the page into the spt. */
		return spt_insert_page(spt, page);
	}
err:
	return false;
}

4. 페이지 찾기 및 삽입 (spt_find_page, spt_insert_page):

주소를 사용하여 보조 페이지 테이블에서 해당 페이지를 찾거나, 새 페이지를 삽입한다.

struct page *
spt_find_page (struct supplemental_page_table *spt UNUSED, void *va UNUSED) {
	struct page *page = NULL;
	/* TODO: Fill this function. */
	return page_lookup(spt, va);
}

bool
spt_insert_page (struct supplemental_page_table *spt UNUSED,
		struct page *page UNUSED) {
	int succ = false;
	/* TODO: Fill this function. */
	struct hash_elem * result = hash_insert(&spt->pages, &page->page_elem);
	if(result == NULL)
		succ = true;
	return succ;
}

5. 페이지 제거 (spt_remove_page):

주어진 페이지를 보조 페이지 테이블에서 제거하고 메모리에서 할당 해제한다.

void
spt_remove_page (struct supplemental_page_table *spt, struct page *page) {
	vm_dealloc_page (page);
	return true;
}

6. 페이지 스왑 아웃 및 프레임 희생자 선택 (vm_evict_frame, vm_get_victim):

메모리에서 프레임을 제거(스왑 아웃)하고, 스왑 아웃할 프레임의 희생자를 결정한다.

static struct frame *
vm_get_victim (void) {
	 /* TODO: The policy for eviction is up to you. */
	struct list_elem *e = list_pop_front(&frame_table);
	struct frame *victim = list_entry(e, struct frame, frame_elem);

	return victim;
}

/* Evict one page and return the corresponding frame.
 * Return NULL on error.*/
static struct frame *
vm_evict_frame (void) {
	struct frame *victim = vm_get_victim ();
	/* TODO: swap out the victim and return the evicted frame. */
	struct page *victim_page = victim->page;
	
	if(swap_out(victim_page)) {

		victim_page->frame = NULL;
		victim->page = NULL;
		memset(victim->kva, 0, PGSIZE);

		return victim;
	}

	return NULL;
}

7. 스택 확장 (vm_stack_growth):

주소가 주어지면 스택을 확장하는 기능을 제공한다. 주소가 스택 확장 가능 범위 내에 있는지 확인 후 확장을 수행한다.

static void
vm_stack_growth (void *addr UNUSED) {
    if(vm_alloc_page(VM_ANON | VM_MARKER_0, pg_round_down(addr), 1))
		thread_current()->stack_bottom -= PGSIZE;
	
}

8. 페이지 폴트 처리 (vm_try_handle_fault):

페이지 폴트가 발생했을 때, 해당 주소에 대한 페이지를 찾고, 필요에 따라 페이지를 로드하거나 스택을 확장하는 로직을 포함한다.

bool
vm_try_handle_fault (struct intr_frame *f, void *addr,
		bool user, bool write, bool not_present) {
	struct supplemental_page_table *spt = &thread_current ()->spt;
	/* TODO: Validate the fault */
	if(addr == NULL || is_kernel_vaddr(addr)){
		return false;
	}
	
	if (!not_present){
		return false;
	}

	void *rsp = f->rsp; // user access인 경우 rsp는 유저 stack을 가리킨다.
    if (!user) // kernel access인 경우 thread에서 rsp를 가져와야 한다.
		rsp = thread_current()->rsp;

	// 스택 확장으로 처리할 수 있는 폴트인 경우, vm_stack_growth를 호출한다.
    if (rsp-8 <= addr  && USER_STACK - 0x100000 <= addr && addr <= USER_STACK)
		vm_stack_growth(pg_round_down(addr));
	
	struct page *page = spt_find_page(spt, addr);
	if (page == NULL){
		return false;
	}
	if (write && !page->is_writable){
		return false;
	}
	
	/* TODO: Your code goes here */
	bool success = vm_do_claim_page (page);
	return success;
}

9. 페이지 및 프레임 클레임 (vm_claim_page, vm_do_claim_page):

주소에 해당하는 페이지를 클레임하고, 물리 메모리에 매핑한다.

bool
vm_claim_page (void *va UNUSED) {
	struct thread *cur = thread_current();
	struct page *page = spt_find_page(&cur->spt, va);
	/* TODO: Fill this function */
	if (page == NULL){
		return false;
	}
	return vm_do_claim_page (page);
}

/* Claim the PAGE and set up the mmu. */
static bool
vm_do_claim_page (struct page *page) {
	struct frame *frame = vm_get_frame ();

	/* Set links */
	frame->page = page;
	page->frame = frame;

	/* TODO: Insert page table entry to map page's VA to frame's PA. */

	struct thread *cur = thread_current();
	pml4_set_page(cur->pml4, page->va, frame->kva, page->is_writable);
	return swap_in(page, frame->kva);
}

10. 보조 페이지 테이블 관련 함수 (supplemental_page_table_init, supplemental_page_table_copy, supplemental_page_table_kill):

보조 페이지 테이블을 초기화하거나, 복사하거나, 종료 처리를 담당한다.

void
supplemental_page_table_init (struct supplemental_page_table *spt UNUSED) {
	hash_init (&spt->pages, page_hash, page_less, NULL);
}

bool
supplemental_page_table_copy (struct supplemental_page_table *dst,
		struct supplemental_page_table *src) {
	struct hash_iterator i;
	struct hash_elem *elem;
	hash_first(&i, &src->pages);
	while ((elem = hash_next(&i))){
		struct page *p = hash_entry(elem, struct page, page_elem);
		enum vm_type type = page_get_type(p);

		if (VM_TYPE(p->operations->type) == VM_UNINIT){
			//if(!vm_alloc_page_with_initializer(VM_ANON, p->va, p->is_writable, p->uninit.init, p->uninit.aux)) // 왜 ANON?
			struct load_info *copy_aux = (struct load_info *)malloc(sizeof(struct load_info));
			memcpy(copy_aux, p->uninit.aux, sizeof(struct load_info));
			if(!vm_alloc_page_with_initializer(type, p->va, p->is_writable, p->uninit.init, copy_aux))
				return false;
		}else{
			if(vm_alloc_page(type, p->va, p->is_writable)
			&& vm_claim_page(p->va)){
				struct page* copy = spt_find_page(dst, p->va);
				memcpy(copy->frame->kva, p->frame->kva, PGSIZE);
				copy->frame->page = copy;
			}else
				return false;
		}
		
	}
	return true;
	
}

void
supplemental_page_table_kill (struct supplemental_page_table *spt UNUSED) {
	/* TODO: Destroy all the supplemental_page_table hold by thread and
	* TODO: writeback all the modified contents to the storage. */
	// hash_destroy(&spt->pages, page_dealloc);
	hash_clear(&spt->pages, page_dealloc);
}