malloc_monitor.c

#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/uaccess.h>
#include <linux/kernel.h>
#include <linux/seq_file.h>
#include <linux/pgtable.h>
#include <linux/mm.h>
#include <linux/io.h>
#include "mem_ioctl.h"

struct monitor_data {
    pid_t pid;
    unsigned int type;

    unsigned long target_va;

    unsigned long pgd_addr;
    unsigned long pgd_val;

    unsigned long p4d_addr;
    unsigned long p4d_val;

    unsigned long pud_addr;
    unsigned long pud_val;

    unsigned long pmd_addr;
    unsigned long pmd_val;

    unsigned long pte_addr;
    unsigned long pte_val;

    unsigned long final_pa;

    struct list_head list;

    /* 출처 : https://elixir.bootlin.com/linux/v2.6.39/source/include/linux/types.h#L222 && 
    https://bbingju.wordpress.com/2013/08/25/linux-kernel-list-h/
    struct list_head {
        struct list_head *next, *prev;
    }; */
};

// struct manual_result {
//     pgd_t *pgd;
//     unsigned long pgd_entry;

//     p4d_t *p4d;
//     unsigned long p4d_entry;

//     pud_t *pud;
//     unsigned long pud_entry;

//     pmd_t *pmd;
//     unsigned long pmd_entry;

//     pte_t *pte;
//     unsigned long pte_entry;
// };


// static inline void *entry_to_kva(unsigned long entry) {
//     return __va(entry & PTE_PFN_MASK);
// }

// manual_page_table_walk은 출력에 영향 X / 공부를 위한 코드임
// static void manual_page_table_walk(struct mm_struct *mm,
//                                    unsigned long va,
//                                    struct manual_result *res) {
//     // 출처 : https://velog.io/@aplbly/Linux-%ED%8E%98%EC%9D%B4%EC%A7%80-%ED%85%8C%EC%9D%B4%EB%B8%94-%EA%B5%AC%EC%A1%B0
//     // 출처 : https://events.linuxfoundation.org/wp-content/uploads/2022/03/Huge-Page-Concepts.pdf
    
//     memset(res, 0, sizeof(struct manual_result));

//     unsigned long pgd_idx = (va >> PGDIR_SHIFT) & 0x1FF; // 상위 비트 마스킹, 하위 9비트 오프셋 가져옴 (x86_64)
//     unsigned long p4d_idx = (va >> P4D_SHIFT)  & 0x1FF;
//     unsigned long pud_idx = (va >> PUD_SHIFT)  & 0x1FF;
//     unsigned long pmd_idx = (va >> PMD_SHIFT)  & 0x1FF;
//     unsigned long pte_idx = (va >> PAGE_SHIFT)  & 0x1FF;

//     // 안전하게 하려면 (PTRS_PER_PTE - 1)
//     // 출처 : https://elixir.bootlin.com/linux/v6.14/source/include/linux/pgtable.h#L67
//     // unsigned long pgd_idx = (va >> PGDIR_SHIFT) & (PTRS_PER_PTE - 1);
//     // unsigned long p4d_idx = (va >> P4D_SHIFT)  & (PTRS_PER_PTE - 1);
//     // unsigned long pud_idx = (va >> PUD_SHIFT)  & (PTRS_PER_PTE - 1);
//     // unsigned long pmd_idx = (va >> PMD_SHIFT)  & (PTRS_PER_PTE - 1);
//     // unsigned long pte_idx = (va >> PAGE_SHIFT)  & (PTRS_PER_PTE - 1);

//     res->pgd = mm->pgd + pgd_idx;
//     res->pgd_entry = pgd_val(*res->pgd);
//     if (res->pgd_entry == 0) return;
//     void *pud_base;

//     if (PTRS_PER_P4D == 1) {
//         // 출처 : https://docs.kernel.org/mm/page_tables.html#page-table-folding
//         // P4D가 없으므로 PGD 값을 그대로 P4D로 취급
//         res->p4d = (p4d_t *)res->pgd;
//         res->p4d_entry = res->pgd_entry;
//         pud_base = entry_to_kva(res->pgd_entry);
//     } else {
//         // 실제 P4D 테이블이 존재

//         /* 참고 : https://elixir.bootlin.com/linux/v6.14/source/arch/x86/include/asm/pgtable.h#L1190
//         static inline unsigned long pgd_page_vaddr(pgd_t pgd)
//         {
//             return (unsigned long)__va((unsigned long)pgd_val(pgd) & PTE_PFN_MASK);
//         }
//         */
//         void *p4d_base = entry_to_kva(res->pgd_entry);
//         res->p4d = ((p4d_t *)p4d_base) + p4d_idx;
//         res->p4d_entry = p4d_val(*res->p4d);
//         pud_base = entry_to_kva(res->p4d_entry);
//         if (res->p4d_entry == 0) return;
//     }

//     {
//         res->pud = ((pud_t *)pud_base) + pud_idx;
//         res->pud_entry = pud_val(*res->pud);
//         if (res->pud_entry == 0) return;
//         if (res->pud_entry & _PAGE_PSE) {
//             return;
//         }
//     }

//     {
//         void *pmd_base = entry_to_kva(res->pud_entry);
//         res->pmd = ((pmd_t *)pmd_base) + pmd_idx;
//         res->pmd_entry = pmd_val(*res->pmd);
//         if (res->pmd_entry == 0) return;
//         // #define _PAGE_PSE (_AT(pteval_t, 1) << _PAGE_BIT_PSE): 즉 7번째 bit만 1로 세팅됨
//         // #define _PAGE_BIT_PSE		7	/* 4 MB (or 2MB) page */
//         // 출처 : https://elixir.bootlin.com/linux/v6.14/source/arch/x86/include/asm/pgtable_types.h#L17
//         if (res->pmd_entry & _PAGE_PSE) {
//             return;
//         }
//     }

//     {
//         void *pte_base = entry_to_kva(res->pmd_entry);
//         res->pte = ((pte_t *)pte_base) + pte_idx;
//         res->pte_entry = pte_val(*res->pte);
//     }
// }


// static void compare_walk_results(const struct monitor_data *m,
//                                  const struct manual_result *man) {
//     if (m->pgd_val == man->pgd_entry) {
//         pr_info("PGD ENTRY MATCH\n");
//     } else {
//         pr_info("PGD ENTRY MISMATCH: macro=0x%016lx manual=0x%016lx\n",
//                 m->pgd_val, man->pgd_entry);
//     }

//     if (m->p4d_val == man->p4d_entry) {
//         pr_info("P4D ENTRY MATCH\n");
//     } else {
//         pr_info("P4D ENTRY MISMATCH: macro=0x%016lx manual=0x%016lx\n",
//                 m->p4d_val, man->p4d_entry);
//     }

//     if (m->pud_val == man->pud_entry) {
//         pr_info("PUD ENTRY MATCH\n");
//     } else {
//         pr_info("PUD ENTRY MISMATCH: macro=0x%016lx manual=0x%016lx\n",
//                 m->pud_val, man->pud_entry);
//     }

//     if (m->pmd_val == man->pmd_entry) {
//         pr_info("PMD ENTRY MATCH\n");
//     } else {
//         pr_info("PMD ENTRY MISMATCH: macro=0x%016lx manual=0x%016lx\n",
//                 m->pmd_val, man->pmd_entry);
//     }

//     if (m->pte_val == man->pte_entry) {
//         pr_info("PTE ENTRY MATCH\n");
//     } else {
//         pr_info("PTE ENTRY MISMATCH: macro=0x%016lx manual=0x%016lx\n",
//                 m->pte_val, man->pte_entry);
//     }
// }

/*
출처 : https://elixir.bootlin.com/linux/v2.6.39/source/arch/x86/include/asm/pgtable.h#L147
static inline int pmd_large(pmd_t pte)
{
	return (pmd_flags(pte) & (_PAGE_PSE | _PAGE_PRESENT)) ==
		(_PAGE_PSE | _PAGE_PRESENT);
}
*/

static inline bool is_2MB_huge_page(pmd_t pmd) {
    return (pmd_flags(pmd) & (_PAGE_PSE | _PAGE_PRESENT)) ==
           (_PAGE_PSE | _PAGE_PRESENT);
}

static inline bool is_1GB_huge_page(pud_t pud) {
    return (pud_flags(pud) & (_PAGE_PSE | _PAGE_PRESENT)) ==
           (_PAGE_PSE | _PAGE_PRESENT);
}

// 전역 변수

static LIST_HEAD(data_head);
static DEFINE_SPINLOCK(data_list_lock);
// static int pid_num = 0;

static void fill_page_table_info_and_pa(struct monitor_data *data,
                                        pid_t pid,
                                        unsigned int cmd,
                                        struct mm_struct *mm,
                                        unsigned long va) {


    memset(data, 0, sizeof(struct monitor_data)); // 0으로 초기화

    data->pid = pid;
    data->type = cmd;

    data->target_va = va;

    // 출처 : 8강 PPT 20p~22p.
    // 출처 : https://elixir.bootlin.com/linux/v6.14/source/arch/alpha/include/asm/pgtable.h#L277
    
    pgd_t *pgd = pgd_offset(mm, va);
    data->pgd_addr = (unsigned long) pgd;
    // https://elixir.bootlin.com/linux/v6.14/source/arch/s390/include/asm/page.h#L110
    data->pgd_val  = pgd_val(*pgd);
    // 출처 : https://www.kernel.org/doc/gorman/html/understand/understand006.html
    if (pgd_none(*pgd) || pgd_bad(*pgd)) // 엔트리가 없음 즉 다음 페이지 테이블이 없음 or 손상됨
        return;
    
    p4d_t *p4d = p4d_offset(pgd, va);
    data->p4d_addr = (unsigned long)p4d;
    data->p4d_val = p4d_val(*p4d);
    if (p4d_none(*p4d) || p4d_bad(*p4d))
        return;

    pud_t *pud = pud_offset(p4d, va);
    data->pud_addr = (unsigned long) pud;
    data->pud_val  = pud_val(*pud);
    if (pud_none(*pud))
        return;

    if (is_1GB_huge_page(*pud)) {
        // unsigned long offset_1GB = ((va << (64 - 30)) >> (64 - 30));
        // unsigned long pa_shift = (data->pud_val >> 30) << 30 | offset_1GB;

        unsigned long pa_mask  = ( (data->pud_val & PUD_MASK) & PTE_PFN_MASK) | (va & ~PUD_MASK);

        // pr_info("1GB huge page detected");
        // pr_info("  PA shift = 0x%016lx", pa_shift);
        // pr_info("  PA mask  = 0x%016lx", pa_mask);

        // if (pa_shift == pa_mask)
        //     pr_info("-> MATCH\n");
        // else
        //     pr_info("-> MISMATCH\n");

        data->final_pa = pa_mask;
        return;
    }

    if (pud_bad(*pud))
        return;

    pmd_t *pmd = pmd_offset(pud, va);
    data->pmd_addr = (unsigned long) pmd;
    data->pmd_val  = pmd_val(*pmd);
    if (pmd_none(*pmd)) 
        return;

    if (is_2MB_huge_page(*pmd)) {
        // unsigned long offset_2MB = ((va << (64 - 21)) >> (64 - 21));
        // unsigned long pa_shift = (data->pmd_val >> 21) << 21 | offset_2MB;

        // 하위 비트를 제거하고 상위 PFN 비트 추출
        unsigned long pa_mask  = ( (data->pmd_val & PMD_MASK) & PTE_PFN_MASK) | (va & ~PMD_MASK);
        
        // unsigned long pa_mask_s  = ( data->pmd_val & PTE_PFN_MASK) | (va & ~PMD_MASK);

        // pr_info("2MB huge page detected");
        // pr_info("  PA shift = 0x%016lx", pa_shift);
        // pr_info("  PA mask  = 0x%016lx", pa_mask);

        // if (pa_shift == pa_mask)
        //     pr_info("-> MATCH\n");
        // else
        //     pr_info("-> MISMATCH\n");

        // pr_info("2MB huge page detected");
        // pr_info("  PA mask v1 = 0x%016lx", pa_mask_s);
        // pr_info("  PA mask v2  = 0x%016lx", pa_mask);

        // if (pa_mask_s == pa_mask)
        //     pr_info("-> MATCH\n");
        // else
        //     pr_info("-> MISMATCH\n");

        data->final_pa = pa_mask;
        return;
    }

    if (pmd_bad(*pmd))
        return;
    
    pte_t *pte = pte_offset_kernel(pmd, va);
    data->pte_addr = (unsigned long) pte;
    data->pte_val  = pte_val(*pte);

    if (pte_none(*pte)) { // !(pte.pte & ~(_PAGE_KNL_ERRATUM_MASK));
        return;
    } else {
        // unsigned long offset_4KB = va & 0xFFF;
        // unsigned long pa_shift = ((data->pte_val >> 12) << 12) | offset_4KB;

        /* Extracts the PFN from a (pte|pmd|pud|pgd)val_t of a 4KB page */
        // #define PTE_PFN_MASK		((pteval_t)PHYSICAL_PAGE_MASK)
        // 출처 : https://elixir.bootlin.com/linux/v6.14/source/arch/x86/include/asm/pgtable_types.h#L289

        unsigned long pa_mask  = (data->pte_val & PTE_PFN_MASK) | (va & (PAGE_SIZE - 1));

        // pr_info("4KB page");
        // pr_info("  PA shift = 0x%016lx", pa_shift);
        // pr_info("  PA mask  = 0x%016lx", pa_mask);

        // if ((pa_shift == pa_mask))
        //     pr_info("-> MATCH\n");
        // else
        //     pr_info("-> MISMATCH\n");

        data->final_pa = pa_mask;
    }
}


static void print_data(struct seq_file *m, struct monitor_data *d, int count) {

    unsigned int cmd;
    cmd = d->type;

    if (cmd == CMD_KMALLOC) {
        seq_printf(m, "[%d] PID: %d | Type: %s\n", count,  d->pid, "KMALLOC");
        seq_printf(m, "------------------------------------------------------------\n");
        seq_printf(m, "Target VA : 0x%016lx\n", d->target_va);
        seq_printf(m, "Final PA : 0x%016lx\n", d->final_pa);
    } else if ((cmd == CMD_MALLOC || cmd == CMD_ACCESS)) {
        seq_printf(m, "[%d] PID: %d | Type: %s\n", count, d->pid, (cmd == CMD_MALLOC)  ? "MALLOC" : "ACCESS");
        seq_printf(m, "------------------------------------------------------------\n");
        seq_printf(m, "Target VA : 0x%016lx\n", d->target_va);
        seq_printf(m, "    PGD   : Addr = 0x%016lx, Val = 0x%016lx\n", d->pgd_addr, d->pgd_val);
        seq_printf(m, "    PUD   : Addr = 0x%016lx, Val = 0x%016lx\n", d->pud_addr, d->pud_val);
        seq_printf(m, "    PMD   : Addr = 0x%016lx, Val = 0x%016lx\n", d->pmd_addr, d->pmd_val);
        seq_printf(m, "    PTE   : Addr = 0x%016lx, Val = 0x%016lx\n", d->pte_addr, d->pte_val);

        if (d->final_pa == 0) {
            seq_printf(m, "Final PA  : (Not Mapped)\n");
        }
        else {
            seq_printf(m, "Final PA  : 0x%016lx\n", d->final_pa);
        }

    } else {

    }

    seq_printf(m, "============================================================\n");
}



static long malloc_monitor_ioctl(struct file *f, unsigned int cmd, unsigned long arg) {
    
    unsigned long va = arg;
    // pr_info("malloc_monitor_ioctl cmd = 0x%x, arg = 0x%016lx\n", cmd, arg);

    // struct pid *find_get_pid(pid_t nr) 출처 : https://elixir.bootlin.com/linux/v6.14/source/kernel/pid.c#L473
    // find_get_pid는 내부에서 락을 걸어줌
    pid_t current_pid = current->pid;
    struct pid *target_pid = find_get_pid(current_pid); // current_pid에 해당하는 pid 구조체를 찾음
    
    if (!target_pid) {
        pr_info("No such PID: %d\n", current_pid);
        return -ESRCH; /* No such process */ 
        // 출처 : https://elixir.bootlin.com/linux/v6.14/source/include/uapi/asm-generic/errno-base.h#L7
    }

    // struct task_struct *get_pid_task(struct pid *pid, enum pid_type type) 출처 : https://elixir.bootlin.com/linux/v6.14/source/kernel/pid.c#L461
    // get_pid_task는 내부에서 락을 걸어줌 출처 : https://stackoverflow.com/questions/8547332/efficient-way-to-find-task-struct-by-pid
    struct task_struct *task = get_pid_task(target_pid, PIDTYPE_PID); // pid 구조체에서 task_struct 구조체를 얻음

    if (!task) {
        pr_info("No task found for PID: %d\n", current_pid);
        put_pid(target_pid); // pid 구조체 메모리 해제
        return -ESRCH;
    }

    /*
    typedef struct { unsigned long pte; } pte_t;
    typedef struct { unsigned long pmd; } pmd_t;
    typedef struct { unsigned long pud; } pud_t;
    typedef struct { unsigned long pgd; } pgd_t;
    */
    
    // 커널 매크로 사용
    if (cmd == CMD_MALLOC || cmd == CMD_ACCESS) {
        // pr_info("CMD_MALLOC cmd = 0x%x, arg = 0x%016lx\n", cmd, arg);

        struct mm_struct *mm = task->mm;
        if (!mm) { 
            put_task_struct(task);
            put_pid(target_pid); 
            return -EINVAL; 
        }

        // 출처 : https://bbingju.wordpress.com/2013/08/25/linux-kernel-list-h/
        struct monitor_data *malloc_data;
        
        malloc_data = kmalloc(sizeof(*malloc_data), GFP_KERNEL);
        // struct monitor_data의 instance가 저장된 메모리의 시작 주소를 반환함
        if (!malloc_data) {
            put_task_struct(task);
            put_pid(target_pid);
            return -ENOMEM;
        }


        // Lock for Traversing page tables - Simply reading page tables in order to traverse them. This only requires that the VMA is kept stable, so a lock which establishes this suffices for traversal
        // 출처 : https://www.kernel.org/doc/html/v6.13-rc6/mm/process_addrs.html
        mmap_read_lock(mm);

        // 직접 계산해보기 (연습 & 공부) -> 로컬 변수로 임시 저장
        // struct manual_result manu;
        // manual_page_table_walk(mm, va, &manu);

        // 실제 커널 자료구조에서 데이터 가져옴
        fill_page_table_info_and_pa(malloc_data, current_pid, cmd, mm, va);
        // compare_walk_results(malloc_data, &manu);


        /** 출처 : https://elixir.bootlin.com/linux/v2.6.39/source/include/linux/list.h#L66
        * list_add_tail - add a new entry
        * @new: new entry to be added
        * @head: list head to add it before
        *
        * Insert a new entry before the specified head.
        * This is useful for implementing queues.
        list_add_tail(struct list_head *new, struct list_head *head)
        */

        mmap_read_unlock(mm);

        spin_lock(&data_list_lock); 
        list_add_tail(&malloc_data->list, &data_head); // 전역 변수 data_head에 malloc_data 추가
        spin_unlock(&data_list_lock);
    }
    // else if (cmd == CMD_ACCESS) {
    //     //pr_info("CMD_ACCESS cmd = 0x%x, arg = 0x%016lx\n", cmd, arg);

    //     // 출처 : https://bbingju.wordpress.com/2013/08/25/linux-kernel-list-h/
    //     struct monitor_data *access_data;

    //     access_data = kmalloc(sizeof(*access_data), GFP_KERNEL);
    //     // struct monitor_data의 instance가 저장된 메모리의 시작 주소를 반환함
    //     if (!access_data) {
    //         return -ENOMEM;
    //     }
        
    //     // 실제 커널 자료구조에서 데이터 가져옴
    //     fill_page_table_info_and_pa(access_data, current_pid, cmd, mm, va);
    //     compare_walk_results(access_data, &manu);

    //     mmap_read_unlock(mm);

    //     spin_lock(&data_list_lock);
    //     list_add_tail(&access_data->list, &data_head);
    //     spin_unlock(&data_list_lock);
    // }
    else if (cmd == CMD_KMALLOC) {
        //pr_info("CMD_KMALLOC cmd = 0x%x, arg = 0x%016lx\n", cmd, arg);

        void *km_va;

        km_va = kmalloc(1024, GFP_KERNEL);
        if (!km_va) {
            put_task_struct(task);
            put_pid(target_pid);
            return -ENOMEM;
        }

        // 출처 : https://bbingju.wordpress.com/2013/08/25/linux-kernel-list-h/
        struct monitor_data *kdata;

        kdata = kmalloc(sizeof(*kdata), GFP_KERNEL);
        // struct monitor_data의 instance가 저장된 메모리의 시작 주소를 반환함
        if (!kdata) {
            put_task_struct(task);
            put_pid(target_pid);
            if (km_va) kfree(km_va);
            return -ENOMEM;
        }

        // 실제 커널 자료구조에서 데이터 가져옴
        
        kdata->pid = current_pid;
        kdata->type = cmd;

        kdata->target_va = (unsigned long) km_va;
        
        // if ((unsigned long) km_va - PAGE_OFFSET != virt_to_phys(km_va)) {
        //     pr_info("PA MISMATCH: (km_va - PAGE_OFFSET)=0x%016lx virt_to_phys=0x%016lx\n",
        //         (unsigned long) km_va - PAGE_OFFSET, (unsigned long) virt_to_phys(km_va));
        // } else {
        //     pr_info("PA MATCH: (km_va - PAGE_OFFSET)=0x%016lx virt_to_phys=0x%016lx\n",
        //         (unsigned long) km_va - PAGE_OFFSET, (unsigned long) virt_to_phys(km_va));
        // }
        // 출처 : 9강 PPT 28p.
        // It is only valid to use this function on addresses directly mapped or allocated via kmalloc. 출처 : https://manpages.debian.org/jessie/linux-manual-3.16/virt_to_phys.9
        kdata->final_pa = virt_to_phys(km_va);

        spin_lock(&data_list_lock);
        list_add_tail(&kdata->list, &data_head);
        spin_unlock(&data_list_lock);

        if (km_va) kfree(km_va);

            
    }
    else {
        pr_info("Invalid argument cmd = 0x%x, arg = 0x%016lx\n", cmd, arg);
        put_task_struct(task);
        put_pid(target_pid); 
        return -EINVAL; /* Invalid argument */
    }

    if (task) {
        put_task_struct(task); // 더 이상 필요하지 않는 task_struct는 put_task_struct로 메모리 해제 출처 : https://remnant24c1.tistory.com/531
    }
    if (target_pid) {
        put_pid(target_pid); // pid 구조체도 마찬가지로 메모리에서 해제
    }

    return 0;
}

static int malloc_monitor_read(struct seq_file *m, void *v) {
    seq_printf(m, "ID: 2021123119\n");
    seq_printf(m, "Name: Park, SungJe\n\n");

    /**
    * list_for_each	-	iterate over a list
    * @pos:	the &struct list_head to use as a loop cursor.
    * @head:	the head for your list.
    */

    /** 출처 : https://elixir.bootlin.com/linux/v6.14/source/include/linux/list.h#L594
    * list_entry - get the struct for this entry
    * @ptr:	the &struct list_head pointer.
    * @type:	the type of the struct this is embedded in.
    * @member:	the name of the list_head within the struct. 
    (컴파일러는 list_head의 포인터인 것만 알지, 그 list_head가 어떤 monitor_data의 몇 번째 필드를 가르키는지는 모름 -> 따라서 member가 뭔지 알아야 역산 가능)
    */

    struct list_head *pos;
    struct monitor_data *result_data;
    int count = 0;

    seq_printf(m, "============================================================\n");

    spin_lock(&data_list_lock);
    list_for_each(pos, &data_head) {
        result_data = list_entry(pos, struct monitor_data, list); //list 필드를 포함하는 struct monitor_data 구조체의 시작 주소를 계산해서 result_data에 저장
        print_data(m, result_data, ++count);
    }
    spin_unlock(&data_list_lock);
    return 0;
}


static int malloc_monitor_open(struct inode *inode, struct file *file) {
    return single_open(file, malloc_monitor_read, NULL);
}

static const struct proc_ops malloc_monitor_fops = {
    .proc_ioctl = malloc_monitor_ioctl,
    .proc_open    = malloc_monitor_open,
    .proc_read    = seq_read,
    .proc_lseek   = seq_lseek,
    .proc_release = single_release,
    };

static int __init malloc_monitor_init(void) {
    proc_create("malloc_monitor", 0666, NULL, &malloc_monitor_fops); // 0666 권한으로 쓰기 모두 허용 출처 : https://reakwon.tistory.com/208
    pr_info("malloc_monitor module loaded, /proc/malloc_monitor created.\n");
    return 0;
}

static void __exit malloc_monitor_exit(void) {

    struct list_head *pos, *q;
    struct monitor_data *d;


    // 출처 : https://satisfactoryplace.tistory.com/200
    // list_for_each_safe는 next 포인터를 미리 가져와 현재 노드를 삭제해도 안전함
    list_for_each_safe(pos, q, &data_head) {
        d = list_entry(pos, struct monitor_data, list);
        list_del(pos);
        kfree(d);
    }

    remove_proc_entry("malloc_monitor", NULL);
    pr_info("malloc_monitor module unloaded, /proc/malloc_monitor removed.\n");
}

module_init(malloc_monitor_init);
module_exit(malloc_monitor_exit);

MODULE_LICENSE("GPL");