From 7362759ae97dff62067426086c5dd04ec329d568 Mon Sep 17 00:00:00 2001 From: Liu Yuntao Date: Sat, 12 Aug 2023 17:06:09 +0800 Subject: [PATCH] =?UTF-8?q?=E6=B7=BB=E5=8A=A0sysboost=20link=E6=A0=87?= =?UTF-8?q?=E8=AE=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/binfmt_rto/binfmt_rto.c | 114 ++++++++++++----------------- src/binfmt_rto/binfmt_rto.h | 4 +- src/binfmt_rto/loader_device.c | 127 ++++++++++++++++++--------------- src/binfmt_rto/loader_device.h | 4 ++ src/binfmt_rto/main.c | 1 - src/binfmt_rto/rto_populate.c | 45 ++++++++---- src/elf_hugepage.c | 43 ++++++++--- src/elf_hugepage.h | 3 + 8 files changed, 194 insertions(+), 147 deletions(-) diff --git a/src/binfmt_rto/binfmt_rto.c b/src/binfmt_rto/binfmt_rto.c index 2167c9c..6f709cf 100644 --- a/src/binfmt_rto/binfmt_rto.c +++ b/src/binfmt_rto/binfmt_rto.c @@ -53,7 +53,6 @@ #include #endif #include "main.h" -#include "loader_device.h" #include "binfmt_rto.h" #ifndef CONFIG_ELF_SYSBOOST @@ -1025,7 +1024,7 @@ static int parse_elf_properties(struct file *f, const struct elf_phdr *phdr, } #ifdef CONFIG_ELF_SYSBOOST -static struct file * try_get_rto_file(struct file *file) +struct file *try_get_rto_file(struct file *file) { char *buffer, *rto_path; struct file *rto_file; @@ -1112,37 +1111,6 @@ static inline void ___start_thread(struct pt_regs *regs, unsigned long pc, } #endif /* CONFIG_ARM64 */ -// static bool check_elf_xattr(struct linux_binprm *bprm) -// { -// char *xattr = NULL; -// int xattr_size = 0; - -// return false; - -// // try to get attr from bprm -// xattr_size = vfs_getxattr(bprm->file->f_path.dentry, -// "trusted.flags", NULL, 0); -// if (xattr_size < 0) { -// return false; -// } - -// xattr = kvmalloc(xattr_size, GFP_KERNEL); -// if (xattr == NULL) { -// return false; -// } -// xattr_size = vfs_getxattr(bprm->file->f_path.dentry, -// "trusted.flags", xattr, xattr_size); -// if (xattr_size <= 0) { -// kvfree(xattr); -// return false; -// } - -// if (memcmp(xattr, "true", xattr_size)) { -// return false; -// } -// return true; -// } - #endif /* CONFIG_ELF_SYSBOOST */ static int load_elf_binary(struct linux_binprm *bprm) @@ -1162,27 +1130,53 @@ static int load_elf_binary(struct linux_binprm *bprm) unsigned long start_code, end_code, start_data, end_data; unsigned long reloc_func_desc __maybe_unused = 0; int executable_stack = EXSTACK_DEFAULT; - struct elfhdr *elf_ex = (struct elfhdr *)bprm->buf; + struct elfhdr *elf_ex; struct elfhdr *interp_elf_ex = NULL; struct arch_elf_state arch_state = INIT_ARCH_ELF_STATE; struct mm_struct *mm; struct pt_regs *regs; + struct dentry *dentry = d_find_alias(bprm->file->f_inode); #ifdef CONFIG_ELF_SYSBOOST - bool is_rto_format = false; - -// load_rto: + bool is_rto_format, is_rto_symbolic_link; + struct loaded_rto *loaded_rto = NULL; + struct list_head *preload_seg_pos = NULL; + struct loaded_seg *loaded_seg; + // TODO check rto inode! + +load_rto: + elf_ex = (struct elfhdr *)bprm->buf; is_rto_format = elf_ex->e_flags & OS_SPECIFIC_FLAG_RTO; + is_rto_symbolic_link = IS_SYSBOOST_RTO_SYMBOLIC_LINK(bprm->file->f_inode); retval = -ENOEXEC; /* close feature to rmmod this ko */ if (!use_rto) { goto out; } - if (!is_rto_format && !IS_SYSBOOST_RTO_SYMBOLIC_LINK(bprm->file->f_inode)) { + if (!is_rto_format && !is_rto_symbolic_link) { goto out; } - pr_info("lyt enter rto\n"); + + /* replace app.rto file, then use binfmt */ + if (is_rto_symbolic_link && !is_rto_format) { + struct inode *inode = bprm->file->f_inode; + loaded_rto = find_loaded_rto(bprm->file->f_inode); + int ret = try_replace_file(bprm); + if (ret) { + /* limit print */ + printk("replace rto file fail, %d\n", ret); + goto out; + } + pr_info("replace rto file success, loaded_rto: 0x%lx, inode: 0x%lx\n", + loaded_rto, inode); + goto load_rto; + } + + /* loading rto from now on */ + if (debug) { + printk("exec in rto mode, is_rto_format %d\n", is_rto_format); + } #endif /* First of all, some simple consistency checks */ @@ -1202,29 +1196,6 @@ static int load_elf_binary(struct linux_binprm *bprm) if (!elf_phdata) goto out; -// #ifdef CONFIG_ELF_SYSBOOST -// /* replace app.rto file, then use binfmt */ -// if (check_elf_xattr(bprm)) { -// int ret = try_replace_file(bprm); -// if (!ret) { -// if (elf_ex->e_flags & OS_SPECIFIC_FLAG_RTO) { -// goto load_rto; -// } else { -// goto out; -// } -// } else { -// /* limit print */ -// printk("replace rto file fail, %d\n", ret); -// goto out; -// } -// } -// if (!is_rto_format && !(elf_ex->e_flags & OS_SPECIFIC_FLAG_HUGEPAGE)) -// goto out; -// if (debug) { -// printk("exec in rto mode, is_rto_format %d\n", is_rto_format); -// } -// #endif - elf_ppnt = elf_phdata; for (i = 0; i < elf_ex->e_phnum; i++, elf_ppnt++) { char *elf_interpreter; @@ -1392,6 +1363,8 @@ out_free_interp: start_data = 0; end_data = 0; + if (loaded_rto) + preload_seg_pos = &loaded_rto->segs; /* Now we do a little grungy work by mmapping the ELF image into the correct location in memory. */ for(i = 0, elf_ppnt = elf_phdata; @@ -1400,6 +1373,7 @@ out_free_interp: unsigned long k, vaddr; unsigned long total_size = 0; unsigned long alignment; + unsigned long size, off; if (elf_ppnt->p_type != PT_LOAD) continue; @@ -1509,11 +1483,17 @@ out_free_interp: PTR_ERR((void*)error) : -EINVAL; goto out_free_dentry; } - // size = elf_ppnt->p_filesz + ELF_PAGEOFFSET(elf_ppnt->p_vaddr); - // off = elf_ppnt->p_offset - ELF_PAGEOFFSET(elf_ppnt->p_vaddr); - // pr_info("lyt addr: 0x%lx, off: 0x%lx, size: 0x%lx, \n", - // load_bias + vaddr, off, size); - // rto_populate(bprm->file, error, off, size); + if (preload_seg_pos) { + preload_seg_pos = preload_seg_pos->next; + BUG_ON(preload_seg_pos == &loaded_rto->segs); + loaded_seg = list_entry(preload_seg_pos, + struct loaded_seg, list); + size = elf_ppnt->p_filesz + ELF_PAGEOFFSET(elf_ppnt->p_vaddr); + off = elf_ppnt->p_offset - ELF_PAGEOFFSET(elf_ppnt->p_vaddr); + pr_info("lyt vaddr: 0x%lx, vaddr: 0x%lx, off: 0x%lx, size: 0x%lx\n", + load_bias + vaddr, error, off, size); + // rto_populate(bprm->file, error, off, size, loaded_seg); + } if (!load_addr_set) { load_addr_set = 1; diff --git a/src/binfmt_rto/binfmt_rto.h b/src/binfmt_rto/binfmt_rto.h index 5245684..faf2c56 100644 --- a/src/binfmt_rto/binfmt_rto.h +++ b/src/binfmt_rto/binfmt_rto.h @@ -4,15 +4,17 @@ */ #include +#include "loader_device.h" int rto_populate(struct file *file, unsigned long vaddr, - unsigned long offset, unsigned long size); + unsigned long offset, unsigned long size, struct loaded_seg *loaded_seg); int init_rto_binfmt(void); void exit_rto_binfmt(void); void *load_bprm_buf(struct file *file); struct elf_phdr *load_elf_phdrs(const struct elfhdr *elf_ex, struct file *elf_file); +struct file *try_get_rto_file(struct file *file); int rto_populate_init(void); diff --git a/src/binfmt_rto/loader_device.c b/src/binfmt_rto/loader_device.c index 9e1c922..cb106ee 100644 --- a/src/binfmt_rto/loader_device.c +++ b/src/binfmt_rto/loader_device.c @@ -9,7 +9,6 @@ #include #include #include "main.h" -#include "loader_device.h" #include "binfmt_rto.h" static LIST_HEAD(loaded_rtos); @@ -52,7 +51,7 @@ static int load_seg(struct file *file, struct loaded_rto *loaded_rto, if (!loaded_seg) return -ENOMEM; - for (;;) { + for (; pos < end; ) { page = alloc_pages(GFP_KERNEL | __GFP_ZERO, HUGETLB_PAGE_ORDER); if (!page) { ret = -ENOMEM; @@ -70,9 +69,7 @@ static int load_seg(struct file *file, struct loaded_rto *loaded_rto, } list_add(&page->lru, &loaded_seg->hpages); - pr_info("load_seg: load 1\n"); - if (pos >= end) - break; + pr_info("load_seg: load 1 hpage: 0x%lx\n", page); } list_add(&loaded_seg->list, &loaded_rto->segs); @@ -113,7 +110,7 @@ static void loaded_rto_put(struct loaded_rto *loaded_rto) loaded_rto_free(loaded_rto); } -static int load_rto(struct file *file) +static int preload_rto(struct file *file) { int ret, i; struct loaded_rto *loaded_rto; @@ -121,17 +118,25 @@ static int load_rto(struct file *file) unsigned long size, offset; struct elfhdr *elf_ex; struct elf_phdr *elf_ppnt, *elf_phdata; + struct file *rto_file; + + rto_file = try_get_rto_file(file); + if (IS_ERR(rto_file)) { + return -ENOENT; + } loaded_rto = loaded_rto_alloc(inode); - if (!loaded_rto) - return -ENOMEM; + if (!loaded_rto) { + ret = -ENOMEM; + goto error_alloc; + } - elf_ex = load_bprm_buf(file); + elf_ex = load_bprm_buf(rto_file); if (IS_ERR(elf_ex)) { ret = PTR_ERR(elf_ex); goto error_bprm_buf; } - elf_phdata = load_elf_phdrs(elf_ex, file); + elf_phdata = load_elf_phdrs(elf_ex, rto_file); if (!elf_phdata) { ret = -EIO; goto error_phdrs; @@ -143,13 +148,17 @@ static int load_rto(struct file *file) size = elf_ppnt->p_filesz + ELF_PAGEOFFSET(elf_ppnt->p_vaddr); offset = elf_ppnt->p_offset - ELF_PAGEOFFSET(elf_ppnt->p_vaddr); - ret = load_seg(file, loaded_rto, offset, size); + pr_info("load_seg, offset: 0x%lx, size: 0x%lx\n", offset, size); + ret = load_seg(rto_file, loaded_rto, offset, size); if (ret) goto error_seg; } + list_add(&loaded_rtos, &loaded_rto->list); + kfree(elf_phdata); kfree(elf_ex); + fput(rto_file); return 0; error_seg: @@ -158,6 +167,8 @@ error_phdrs: kfree(elf_ex); error_bprm_buf: loaded_rto_free(loaded_rto); +error_alloc: + fput(rto_file); return ret; } @@ -175,40 +186,31 @@ struct loaded_rto *find_loaded_rto(struct inode *inode) return result; } -static void unload_rto(struct inode *inode) -{ - struct loaded_rto *loaded_rto; +// static void unload_rto(struct inode *inode) +// { +// struct loaded_rto *loaded_rto; - loaded_rto = find_loaded_rto(inode); - if (!loaded_rto) { - pr_err("inode sysboost flag is set, but cannot find loaded_rto!\n"); - return; - } +// loaded_rto = find_loaded_rto(inode); +// if (!loaded_rto) { +// pr_err("inode sysboost flag is set, but cannot find loaded_rto!\n"); +// return; +// } - write_lock(&rtos_rwlock); - list_del(&loaded_rto->list); - write_unlock(&rtos_rwlock); +// write_lock(&rtos_rwlock); +// list_del(&loaded_rto->list); +// write_unlock(&rtos_rwlock); - loaded_rto_put(loaded_rto); -} +// loaded_rto_put(loaded_rto); +// } -static int do_loader_ioctl(char *rto_path) +static int load_rto(struct file *file, unsigned int flags) { - struct file *file; - struct inode *inode; + struct inode *inode = file->f_inode; struct loaded_rto *loaded_rto; - - file = filp_open(rto_path, O_LARGEFILE | O_RDONLY | __FMODE_EXEC, 0); - if (IS_ERR(file)) { - return PTR_ERR(file); - } - inode = file->f_inode; + int ret = 0; spin_lock(&inode->i_lock); - if (IS_SYSBOOST_RTO_SYMBOLIC_LINK(inode)) { - iput(inode); - inode->i_flags &= ~S_SYSBOOST_RTO_SYMBOLIC_LINK; - } else { + if (!IS_SYSBOOST_RTO_SYMBOLIC_LINK(inode)) { ihold(inode); inode->i_flags |= S_SYSBOOST_RTO_SYMBOLIC_LINK; } @@ -216,39 +218,52 @@ static int do_loader_ioctl(char *rto_path) inode, inode->i_flags, atomic_read(&inode->i_count)); spin_unlock(&inode->i_lock); - - loaded_rto = find_loaded_rto(inode); - if (loaded_rto) { - pr_info("lyt find original rto, release it.\n"); - unload_rto(inode); - } else { - load_rto(file); + if (flags & RTO_LOAD_FLAG_PRELOAD) { + loaded_rto = find_loaded_rto(inode); + if (!loaded_rto) + ret = preload_rto(file); } - filp_close(file, NULL); + return ret; +} + +static int unload_rto(struct file *file, unsigned int flags) +{ + struct inode *inode = file->f_inode; + + spin_lock(&inode->i_lock); + if (IS_SYSBOOST_RTO_SYMBOLIC_LINK(inode)) { + iput(inode); + inode->i_flags &= ~S_SYSBOOST_RTO_SYMBOLIC_LINK; + } + pr_info("lyt inode: 0x%pK, i_flags: 0x%x, i_count: %d\n", + inode, inode->i_flags, atomic_read(&inode->i_count)); + spin_unlock(&inode->i_lock); return 0; } static long loader_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - int len = cmd; + unsigned int flags = _IOC_NR(cmd); int ret = 0; - char *data = kmalloc(len + 1, GFP_KERNEL); - if (!data) - return -ENOMEM; + struct fd fd; + // struct file *rto_file; - ret = copy_from_user(data, (char *)arg, len); - if (ret) + fd = fdget(arg); + if (!fd.file) { + ret = -ENOENT; goto out; - data[len] = '\0'; - - pr_info("lyt get ioctl, cmd: %d, arg: 0x%lx, data: %s\n", cmd, arg, data); + } - ret = do_loader_ioctl(data); + if (flags & RTO_LOAD_FLAG_LOAD) { + ret = load_rto(fd.file, flags); + } else { + ret = unload_rto(fd.file, flags); + } out: - kfree(data); + fdput(fd); return ret; } diff --git a/src/binfmt_rto/loader_device.h b/src/binfmt_rto/loader_device.h index a446fce..7a04abe 100644 --- a/src/binfmt_rto/loader_device.h +++ b/src/binfmt_rto/loader_device.h @@ -21,3 +21,7 @@ void __exit loader_device_exit(void); #define S_SYSBOOST_RTO_SYMBOLIC_LINK (1 << 31) /* has rto cache */ #define IS_SYSBOOST_RTO_SYMBOLIC_LINK(inode) ((inode)->i_flags & S_SYSBOOST_RTO_SYMBOLIC_LINK) + +#define RTO_LOAD_FLAG_LOAD 0x1 +#define RTO_LOAD_FLAG_PRELOAD 0x2 +#define RTO_LOAD_FLAG_MAX 0x100 diff --git a/src/binfmt_rto/main.c b/src/binfmt_rto/main.c index 7fe908c..cd61ef5 100644 --- a/src/binfmt_rto/main.c +++ b/src/binfmt_rto/main.c @@ -4,7 +4,6 @@ */ #include "main.h" -#include "loader_device.h" #include "binfmt_rto.h" bool use_rto = false; diff --git a/src/binfmt_rto/rto_populate.c b/src/binfmt_rto/rto_populate.c index 45ac139..3f7f0f2 100644 --- a/src/binfmt_rto/rto_populate.c +++ b/src/binfmt_rto/rto_populate.c @@ -46,14 +46,12 @@ struct follow_page_context { unsigned int page_mask; }; -int check_vma_flags(struct vm_area_struct *vma, unsigned long gup_flags); struct page *follow_page_mask(struct vm_area_struct *vma, unsigned long address, unsigned int flags, struct follow_page_context *ctx); #define proc_symbol(SYM) typeof(SYM) *(SYM) static struct global_symbols { - proc_symbol(check_vma_flags); proc_symbol(follow_page_mask); proc_symbol(__pud_alloc); proc_symbol(__anon_vma_prepare); @@ -66,7 +64,6 @@ static struct global_symbols { #define proc_symbol_char(x) #x static char *global_symbol_names[] = { - proc_symbol_char(check_vma_flags), proc_symbol_char(follow_page_mask), proc_symbol_char(__pud_alloc), proc_symbol_char(__anon_vma_prepare), @@ -134,6 +131,8 @@ static vm_fault_t __rto_do_huge_pmd_anonymous_page(struct vm_fault *vmf, VM_BUG_ON_PAGE(!PageCompound(page), page); + pr_info("enter __rto_do_huge_pmd_anonymous_page\n"); + // if (mem_cgroup_charge(page, vma->vm_mm, gfp)) { // put_page(page); // count_vm_event(THP_FAULT_FALLBACK); @@ -190,6 +189,8 @@ static vm_fault_t __rto_do_huge_pmd_anonymous_page(struct vm_fault *vmf, // pgtable_trans_huge_deposit(vma->vm_mm, vmf->pmd, pgtable); set_pmd_at(vma->vm_mm, haddr, vmf->pmd, entry); + pr_info("set_pmd_at entry: 0x%pK, entry_size: %d\n", + entry, sizeof(entry)); // add_mm_counter(vma->vm_mm, MM_ANONPAGES, HPAGE_PMD_NR); // reliable_page_counter(page, vma->vm_mm, HPAGE_PMD_NR); mm_inc_nr_ptes(vma->vm_mm); @@ -324,6 +325,7 @@ static vm_fault_t __rto_handle_mm_fault(struct vm_area_struct *vma, struct mm_struct *mm = vma->vm_mm; pgd_t *pgd; p4d_t *p4d; + pmd_t *pmd; vm_fault_t ret; pgd = pgd_offset(mm, address); @@ -358,7 +360,16 @@ retry_pud: // } // } + pmd = pmd_offset(vmf.pud, address); + if (pmd) + pr_info("pmd: %pK\n", pmd); + else + pr_info("pmd is null\n"); vmf.pmd = rto_pmd_alloc(mm, vmf.pud, address); + if (vmf.pmd) + pr_info("vmf.pmd: %pK, value: 0x%lx\n", vmf.pmd, pmd_val(*vmf.pmd)); + else + pr_info("vmf.pmd is null\n"); if (!vmf.pmd) return VM_FAULT_OOM; @@ -558,6 +569,9 @@ static long rto_get_user_pages(struct mm_struct *mm, long ret = 0, i = 0; struct vm_area_struct *vma = NULL; struct follow_page_context ctx = { NULL }; + struct list_head *hpage_pos = hpages; + + pr_info("start rto_get_user_pages\n"); if (!nr_pages) return 0; @@ -579,6 +593,10 @@ static long rto_get_user_pages(struct mm_struct *mm, unsigned int foll_flags = gup_flags; unsigned int page_increm; + hpage_pos = hpage_pos->next; + pr_info("hpage_pos: 0x%pK\n", hpage_pos); + BUG_ON(hpage_pos == hpages); + /* first iteration or cross vma bound */ if (!vma || start >= vma->vm_end) { vma = find_extend_vma(mm, start); @@ -592,10 +610,10 @@ static long rto_get_user_pages(struct mm_struct *mm, // goto next_page; // } - if (!vma || ppl_sym.check_vma_flags(vma, gup_flags)) { - ret = -EFAULT; - goto out; - } + // if (!vma || ppl_sym.check_vma_flags(vma, gup_flags)) { + // ret = -EFAULT; + // goto out; + // } // if (is_vm_hugetlb_page(vma)) { // i = follow_hugetlb_page(mm, vma, pages, vmas, @@ -627,6 +645,8 @@ retry: /* TODO try comment here to increase efficiency */ page = ppl_sym.follow_page_mask(vma, start, foll_flags, &ctx); + hpage = list_entry(hpage_pos, struct page, lru); + pr_info("consume hpage 0x%pK, page: 0x%pK\n", hpage, page); if (!page) { ret = rto_faultin_page(vma, start, &foll_flags, locked, hpage); switch (ret) { @@ -666,6 +686,8 @@ next_page: // ctx.page_mask = 0; // } page_increm = 1 + (~(start >> PAGE_SHIFT) & ctx.page_mask); + pr_info("page_increm: %d, ctx.page_mask: 0x%x, i: %ld, nr_pages: %ld", + page_increm, ctx.page_mask, i, nr_pages); if (page_increm > nr_pages) page_increm = nr_pages; i += page_increm; @@ -738,13 +760,11 @@ static long rto_populate_vma_page_range(struct vm_area_struct *vma, } int rto_populate(struct file *file, unsigned long vaddr, - unsigned long offset, unsigned long size) + unsigned long offset, unsigned long size, struct loaded_seg *loaded_seg) { struct mm_struct *mm = current->mm; struct inode *inode = file->f_inode; struct vm_area_struct *vma; - struct loaded_rto *loaded_rto; - struct loaded_seg *loaded_seg; int ret, locked = 1; ret = -EINVAL; @@ -752,11 +772,8 @@ int rto_populate(struct file *file, unsigned long vaddr, if (!vma) goto error; - loaded_rto = find_loaded_rto(inode); - loaded_seg = list_first_entry(&loaded_rto->segs, struct loaded_seg, list); - mmap_read_lock(mm); - rto_populate_vma_page_range(vma, vaddr, size, &locked, &loaded_seg->hpages); + rto_populate_vma_page_range(vma, vaddr, vaddr + size, &locked, &loaded_seg->hpages); mmap_read_unlock(mm); return 0; diff --git a/src/elf_hugepage.c b/src/elf_hugepage.c index 5a23212..ae4a21d 100644 --- a/src/elf_hugepage.c +++ b/src/elf_hugepage.c @@ -19,14 +19,49 @@ #include #include #include +#include #include #include #include +#include "elf_hugepage.h" #include "elf_link_common.h" #include "elf_ext.h" +int elf_set_symbolic_link(char *path, bool state) +{ + int fd_dev, fd_elf, ret = 0; + unsigned int cmd, nr = 0; + + fd_dev = open("/dev/sysboost_loader", 0); + if (fd_dev == -1) { + SI_LOG_ERR("open sysboost_loader device fail\n"); + return -1; + } + fd_elf = open(path, 0); + if (fd_elf == -1) { + SI_LOG_ERR("open %s fail\n", path); + ret = -1; + goto error_elf; + } + + if (state) + nr |= RTO_LOAD_FLAG_LOAD | RTO_LOAD_FLAG_PRELOAD; + + cmd = _IO(0, nr); + + ret = ioctl(fd_dev, cmd, fd_elf); + if (ret) { + SI_LOG_ERR("ioctl error\n"); + } + + close(fd_elf); +error_elf: + close(fd_dev); + return ret; +} + static int _elf_set_flags(char *path, unsigned int flags) { elf_file_t *ef = malloc(sizeof(elf_file_t)); @@ -69,14 +104,6 @@ static int _elf_unset_flags(char *path, unsigned int flags) return 0; } -int elf_set_symbolic_link(char *path, bool state) -{ - if (state) { - return _elf_set_flags(path, OS_SPECIFIC_FLAG_SYMBOLIC_LINK); - } - return _elf_unset_flags(path, OS_SPECIFIC_FLAG_SYMBOLIC_LINK); -} - int elf_set_rto(char *path, bool state) { if (state) { diff --git a/src/elf_hugepage.h b/src/elf_hugepage.h index d115af6..93ed00c 100644 --- a/src/elf_hugepage.h +++ b/src/elf_hugepage.h @@ -20,4 +20,7 @@ void elf_set_hugepage(elf_link_t *elf_link); int elf_set_symbolic_link(char *path, bool state); int elf_set_rto(char *path, bool state); +#define RTO_LOAD_FLAG_LOAD 0x1 +#define RTO_LOAD_FLAG_PRELOAD 0x2 + #endif /* _ELF_HUGEPAGE_H */ -- Gitee