gh0s7/mckernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

todo: modpost undefined errors

Browse Source
This commit is contained in:
CGH0S7
2025-08-23 11:02:25 +08:00
parent 64dbb93260
commit 9ae3a3f374
6 changed files with 93 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
executer/kernel/mcctrl/arch/x86_64/archdeps.c
View File

@ -7,7 +7,11 @@
#include "config.h"
#include "../../mcctrl.h"
#if LINUX_VERSION_CODE < KERNEL_VERSION(5,8,0) && defined(CONFIG_X86_VSYSCALL_EMULATION)
#define gtod (&VVAR(vsyscall_gtod_data))
#else
#define gtod NULL
#endif
//#define SC_DEBUG
@ -24,7 +28,7 @@ static void *vdso_start;
static void *vdso_end;
static struct page **vdso_pages;
#endif
static void *__vvar_page;
static void *__vvar_page_ptr;
static long *hpet_address;
static void **hv_clock;
@ -48,8 +52,8 @@ int arch_symbols_init(void)
return -EFAULT;
#endif
__vvar_page = (void *) kallsyms_lookup_name("__vvar_page");
if (WARN_ON(!__vvar_page))
__vvar_page_ptr = (void *) &__vvar_page;
if (WARN_ON(!__vvar_page_ptr))
return -EFAULT;
hpet_address = (void *) kallsyms_lookup_name("hpet_address");
@ -93,18 +97,18 @@ reserve_user_space(struct mcctrl_usrdata *usrdata, unsigned long *startp, unsign
#define DESIRED_USER_END 0x800000000000
#define GAP_FOR_MCEXEC 0x008000000000UL
end = DESIRED_USER_END;
down_write(&current->mm->mmap_sem);
mmap_write_lock(current->mm);
vma = find_vma(current->mm, 0);
if (vma) {
end = (vma->vm_start - GAP_FOR_MCEXEC) & ~(GAP_FOR_MCEXEC - 1);
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0)
up_write(&current->mm->mmap_sem);
mmap_write_unlock(current->mm);
#endif
start = reserve_user_space_common(usrdata, start, end);
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0)
up_write(&current->mm->mmap_sem);
mmap_write_unlock(current->mm);
#endif
mutex_unlock(&usrdata->reserve_lock);
@ -161,19 +165,19 @@ void get_vdso_info(ihk_os_t os, long vdso_rpa)
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,5,0)
vdso->vvar_is_global = 0;
vdso->vvar_virt = (void *)(-3 * PAGE_SIZE);
vdso->vvar_phys = virt_to_phys(__vvar_page);
vdso->vvar_phys = virt_to_phys(__vvar_page_ptr);
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0)
vdso->vvar_is_global = 0;
vdso->vvar_virt = (void *)(-2 * PAGE_SIZE);
vdso->vvar_phys = virt_to_phys(__vvar_page);
vdso->vvar_phys = virt_to_phys(__vvar_page_ptr);
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(3,16,0)
vdso->vvar_is_global = 0;
vdso->vvar_virt = (void *)(vdso->vdso_npages * PAGE_SIZE);
vdso->vvar_phys = virt_to_phys(__vvar_page);
vdso->vvar_phys = virt_to_phys(__vvar_page_ptr);
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0)
vdso->vvar_is_global = 1;
vdso->vvar_virt = (void *)fix_to_virt(VVAR_PAGE);
vdso->vvar_phys = virt_to_phys(__vvar_page);
vdso->vvar_phys = virt_to_phys(__vvar_page_ptr);
#endif
/* HPET page */

14
executer/kernel/mcctrl/binfmt_mcexec.c
View File

@ -126,8 +126,8 @@ static int load_elf(struct linux_binprm *bprm
if(st == 0){
off = p & ~PAGE_MASK;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4,10,0)
rc = get_user_pages_remote(current, bprm->mm,
bprm->p, 1, FOLL_FORCE, &page, NULL, NULL);
rc = get_user_pages_remote(bprm->mm,
bprm->p, 1, FOLL_FORCE, &page, NULL);
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(4,9,0)
rc = get_user_pages_remote(current, bprm->mm,
bprm->p, 1, FOLL_FORCE, &page, NULL);
@ -234,7 +234,7 @@ static int load_elf(struct linux_binprm *bprm
kfree(pbuf);
return rc;
}
rc = copy_strings_kernel(1, &bprm->interp, bprm);
rc = copy_string_kernel(bprm->interp, bprm);
if (rc < 0){
fput(file);
kfree(pbuf);
@ -242,7 +242,7 @@ static int load_elf(struct linux_binprm *bprm
}
bprm->argc++;
wp = MCEXEC_PATH;
rc = copy_strings_kernel(1, &wp, bprm);
rc = copy_string_kernel(wp, bprm);
if (rc){
fput(file);
kfree(pbuf);
@ -260,19 +260,25 @@ static int load_elf(struct linux_binprm *bprm
fput(bprm->file);
bprm->file = file;
#if LINUX_VERSION_CODE < KERNEL_VERSION(5,8,0)
rc = prepare_binprm(bprm);
if (rc < 0){
kfree(pbuf);
return rc;
}
#endif
kfree(pbuf);
#if LINUX_VERSION_CODE < KERNEL_VERSION(5,8,0)
return search_binary_handler(bprm
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,8,0)
, regs
#endif
);
#else
return -ENOEXEC;
#endif
}
static struct linux_binfmt mcexec_format = {

21
executer/kernel/mcctrl/control.c
View File

@ -978,7 +978,9 @@ static long mcexec_get_cpuset(ihk_os_t os, unsigned long arg)
node = linux_numa_2_mckernel_numa(udp,
cpu_to_node(mckernel_cpu_2_linux_cpu(udp, cpu_prev)));
for_each_cpu_not(cpu, cpus_used) {
for (cpu = 0; cpu < nr_cpu_ids; cpu++) {
if (cpumask_test_cpu(cpu, cpus_used))
continue;
/* Invalid CPU? */
if (cpu >= udp->cpu_info->n_cpus)
break;
@ -1797,7 +1799,7 @@ out:
}
LIST_HEAD(mckernel_exec_files);
DEFINE_SEMAPHORE(mckernel_exec_file_lock);
DEFINE_SEMAPHORE(mckernel_exec_file_lock, 1);
struct mckernel_exec_file {
@ -3262,8 +3264,9 @@ mcexec_uti_attr(ihk_os_t os, struct uti_attr_desc __user *_desc)
&lcache_topo->shared_cpu_map);
}
else {
cpumask_complement(wkmask,
&lcache_topo->shared_cpu_map);
bitmap_complement(cpumask_bits(wkmask),
cpumask_bits(&lcache_topo->shared_cpu_map),
nr_cpumask_bits);
cpumask_and(cpuset, cpuset, wkmask);
}
}
@ -3276,8 +3279,9 @@ mcexec_uti_attr(ihk_os_t os, struct uti_attr_desc __user *_desc)
&lcache_topo->shared_cpu_map);
}
else {
cpumask_complement(wkmask,
&lcache_topo->shared_cpu_map);
bitmap_complement(cpumask_bits(wkmask),
cpumask_bits(&lcache_topo->shared_cpu_map),
nr_cpumask_bits);
cpumask_and(cpuset, cpuset, wkmask);
}
}
@ -3290,8 +3294,9 @@ mcexec_uti_attr(ihk_os_t os, struct uti_attr_desc __user *_desc)
&lcache_topo->shared_cpu_map);
}
else {
cpumask_complement(wkmask,
&lcache_topo->shared_cpu_map);
bitmap_complement(cpumask_bits(wkmask),
cpumask_bits(&lcache_topo->shared_cpu_map),
nr_cpumask_bits);
cpumask_and(cpuset, cpuset, wkmask);
}
}

12
executer/kernel/mcctrl/futex.c
View File

@ -51,7 +51,7 @@ static long uti_wait_event(void *_resp, unsigned long nsec_timeout)
}
}
static int uti_clock_gettime(clockid_t clk_id, struct timespec *tp)
static int uti_clock_gettime(clockid_t clk_id, struct timespec64 *tp)
{
int ret = 0;
struct timespec64 ts64;
@ -60,7 +60,7 @@ static int uti_clock_gettime(clockid_t clk_id, struct timespec *tp)
clk_id, CLOCK_REALTIME, CLOCK_MONOTONIC);
switch (clk_id) {
case CLOCK_REALTIME:
getnstimeofday64(&ts64);
ktime_get_real_ts64(&ts64);
tp->tv_sec = ts64.tv_sec;
tp->tv_nsec = ts64.tv_nsec;
dprintk("%s: CLOCK_REALTIME,%ld.%09ld\n", __func__,
@ -1061,12 +1061,14 @@ static int futex(uint32_t *uaddr, int op, uint32_t val, uint64_t timeout,
switch (cmd) {
case FUTEX_WAIT:
val3 = FUTEX_BITSET_MATCH_ANY;
/* fallthrough */
case FUTEX_WAIT_BITSET:
ret = futex_wait(uaddr, fshared, val, timeout,
val3, clockrt, uti_info);
break;
case FUTEX_WAKE:
val3 = FUTEX_BITSET_MATCH_ANY;
/* fallthrough */
case FUTEX_WAKE_BITSET:
ret = futex_wake(uaddr, fshared, val, val3, uti_info);
break;
@ -1127,7 +1129,7 @@ long do_futex(int n, unsigned long arg0, unsigned long arg1,
int op = (int)arg1;
uint32_t val = (uint32_t)arg2;
struct timespec *utime = (struct timespec *)arg3;
struct timespec ts;
struct timespec64 ts;
uint32_t *uaddr2 = (uint32_t *)arg4;
uint32_t val3 = (uint32_t)arg5;
int flags = op;
@ -1158,12 +1160,12 @@ long do_futex(int n, unsigned long arg0, unsigned long arg1,
}
dprintk("%s: utime=%ld.%09ld\n", __func__, ts.tv_sec, ts.tv_nsec);
if (!timespec_valid(&ts)) {
if (!timespec64_valid(&ts)) {
return -EINVAL;
}
if (op == FUTEX_WAIT_BITSET) { /* User passed absolute time */
struct timespec ats;
struct timespec64 ats;
ret = uti_clock_gettime((flags & FUTEX_CLOCK_REALTIME) ?
CLOCK_REALTIME : CLOCK_MONOTONIC, &ats);

44
executer/kernel/mcctrl/procfs.c
View File

@ -40,7 +40,7 @@ typedef gid_t kgid_t;
struct procfs_entry {
char *name;
mode_t mode;
const struct file_operations *fops;
const struct proc_ops *fops;
};
#define NOD(NAME, MODE, FOP) { \
@ -58,8 +58,8 @@ struct procfs_entry {
static const struct procfs_entry tid_entry_stuff[];
static const struct procfs_entry pid_entry_stuff[];
static const struct procfs_entry base_entry_stuff[];
static const struct file_operations mckernel_forward_ro;
static const struct file_operations mckernel_forward;
static const struct proc_ops mckernel_forward_ro;
static const struct proc_ops mckernel_forward;
static ssize_t mckernel_procfs_read(struct file *file, char __user *buf,
size_t nbytes, loff_t *ppos);
@ -84,7 +84,7 @@ struct procfs_list_entry {
* file.
*/
LIST_HEAD(procfs_file_list);
DEFINE_SEMAPHORE(procfs_file_list_lock);
DEFINE_SEMAPHORE(procfs_file_list_lock, 1);
static char *
getpath(struct procfs_list_entry *e, char *buf, int bufsize)
@ -183,10 +183,10 @@ add_procfs_entry(struct procfs_list_entry *parent, const char *name, int mode,
pde = proc_symlink(name, parent_pde, (char *)opaque);
}
else {
const struct file_operations *fop;
const struct proc_ops *fop;
if(opaque)
fop = (const struct file_operations *)opaque;
fop = (const struct proc_ops *)opaque;
else if(mode & S_IWUSR)
fop = &mckernel_forward;
else
@ -509,7 +509,7 @@ static ssize_t __mckernel_procfs_read_write(
struct proc_dir_entry *dp = PDE(inode);
struct procfs_list_entry *e = dp->data;
#else
struct procfs_list_entry *e = PDE_DATA(inode);
struct procfs_list_entry *e = pde_data(inode);
#endif
loff_t offset = *ppos;
char pathbuf[PROCFS_NAME_MAX];
@ -770,16 +770,16 @@ int procfsm_packet_handler(void *os, int msg, int pid, unsigned long arg,
return 0;
}
static const struct file_operations mckernel_forward_ro = {
.llseek = mckernel_procfs_lseek,
.read = mckernel_procfs_read,
.write = NULL,
static const struct proc_ops mckernel_forward_ro = {
.proc_lseek = mckernel_procfs_lseek,
.proc_read = mckernel_procfs_read,
.proc_write = NULL,
};
static const struct file_operations mckernel_forward = {
.llseek = mckernel_procfs_lseek,
.read = mckernel_procfs_read,
.write = mckernel_procfs_write,
static const struct proc_ops mckernel_forward = {
.proc_lseek = mckernel_procfs_lseek,
.proc_read = mckernel_procfs_read,
.proc_write = mckernel_procfs_write,
};
#define PA_NULL (-1L)
@ -812,7 +812,7 @@ static int mckernel_procfs_buff_open(struct inode *inode, struct file *file)
struct proc_dir_entry *dp = PDE(inode);
struct procfs_list_entry *e = dp->data;
#else
struct procfs_list_entry *e = PDE_DATA(inode);
struct procfs_list_entry *e = pde_data(inode);
#endif
os = osnum_to_os(e->osnum);
@ -1071,12 +1071,12 @@ rep:
return l;
}
static const struct file_operations mckernel_buff_io = {
.llseek = mckernel_procfs_lseek,
.read = mckernel_procfs_buff_read,
.write = NULL,
.open = mckernel_procfs_buff_open,
.release = mckernel_procfs_buff_release,
static const struct proc_ops mckernel_buff_io = {
.proc_lseek = mckernel_procfs_lseek,
.proc_read = mckernel_procfs_buff_read,
.proc_write = NULL,
.proc_open = mckernel_procfs_buff_open,
.proc_release = mckernel_procfs_buff_release,
};
static const struct procfs_entry tid_entry_stuff[] = {

48
executer/kernel/mcctrl/syscall.c
View File

@ -733,7 +733,7 @@ static struct vm_operations_struct rus_vmops = {
static int rus_mmap(struct file *file, struct vm_area_struct *vma)
{
vma->vm_flags |= arch_rus_vm_flags;
vm_flags_set(vma, arch_rus_vm_flags);
vma->vm_ops = &rus_vmops;
return 0;
}
@ -776,10 +776,10 @@ reserve_user_space_common(struct mcctrl_usrdata *usrdata, unsigned long start, u
#if 0
{ /* debug */
struct vm_area_struct *vma;
down_write(&current->mm->mmap_sem);
mmap_write_lock(current->mm);
vma = find_vma(current->mm, start);
vma->vm_flags |= VM_DONTCOPY;
up_write(&current->mm->mmap_sem);
vm_flags_set(vma, VM_DONTCOPY);
mmap_write_unlock(current->mm);
}
#endif
revert_creds(original);
@ -1463,12 +1463,12 @@ static int pager_req_map(ihk_os_t os, int fd, size_t len, off_t off,
}
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0)
down_write(&current->mm->mmap_sem);
mmap_write_lock(current->mm);
va = do_mmap_pgoff(file, ANY_WHERE, len, maxprot,
prot_and_flags, pgoff);
up_write(&current->mm->mmap_sem);
mmap_write_unlock(current->mm);
#else
va = vm_mmap(file, ANY_WHERE, len, maxprot,
prot_and_flags, pgoff << PAGE_SHIFT);
@ -1571,7 +1571,7 @@ static int pager_req_pfn(ihk_os_t os, uintptr_t handle, off_t off, uintptr_t ppf
#define PFN_VALID ((uintptr_t)1 << 63)
pfn = PFN_VALID; /* Use "not present" as the default setting */
down_read(&current->mm->mmap_sem);
mmap_read_lock(current->mm);
retry:
pgd = pgd_offset(current->mm, va);
if (!pgd_none(*pgd) && !pgd_bad(*pgd) && pgd_present(*pgd)) {
@ -1623,7 +1623,9 @@ retry:
goto out_release;
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 8, 0) || \
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 1, 0)
fault = handle_mm_fault(vma, va, flags, NULL);
#elif LINUX_VERSION_CODE >= KERNEL_VERSION(4, 8, 0) || \
(defined(RHEL_RELEASE_CODE) && RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(7, 5))
fault = handle_mm_fault(vma, va, flags);
#else
@ -1656,7 +1658,7 @@ retry:
}
out_release:
up_read(&current->mm->mmap_sem);
mmap_read_unlock(current->mm);
phys = ihk_device_map_memory(dev, ppfn_rpa, sizeof(*ppfn));
ppfn = ihk_device_map_virtual(dev, phys, sizeof(*ppfn), NULL, 0);
@ -1682,9 +1684,9 @@ static int __pager_unmap(struct pager *pager)
int error;
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,5,0)
down_write(&current->mm->mmap_sem);
mmap_write_lock(current->mm);
error = do_munmap(current->mm, pager->map_uaddr, pager->map_len);
up_write(&current->mm->mmap_sem);
mmap_write_unlock(current->mm);
#else
error = vm_munmap(pager->map_uaddr, pager->map_len);
#endif
@ -1749,9 +1751,11 @@ static long pager_req_mlock_list(ihk_os_t os, unsigned long start,
struct vm_area_struct *vma;
kprintf("pager_req_mlock_list: addr(%p)\n", addr);
vma = find_vma(current->mm, 0x7010a0);
for (vma = mm->mmap; vma != NULL; vma = vma->vm_next) {
if (vma->vm_start < start || vma->vm_start > end) continue;
/* Use find_vma to iterate through VMAs */
vma = find_vma(mm, start);
while (vma != NULL) {
if (vma->vm_start > end) break;
kprintf("\t%p: %p -- %p\t%lx\n", vma,
(void*)vma->vm_start, (void*)vma->vm_end,
vma->vm_flags & VM_LOCKED);
@ -1766,6 +1770,8 @@ static long pager_req_mlock_list(ihk_os_t os, unsigned long start,
addrpair->flag = vma->vm_flags;
addrpair++;
}
/* Use find_vma to get next VMA */
vma = find_vma(mm, vma->vm_end);
}
full:
return cnt;
@ -2129,14 +2135,14 @@ static int remap_user_space(uintptr_t rva, size_t len, int prot)
uintptr_t map;
dprintk("remap_user_space(%lx,%lx,%x)\n", rva, len, prot);
down_write(&mm->mmap_sem);
mmap_write_lock(mm);
vma = find_vma(mm, rva);
if (!vma || (rva < vma->vm_start)) {
printk("remap_user_space(%lx,%lx,%x):find_vma failed. %p %lx %lx\n",
rva, len, prot, vma,
(vma)? vma->vm_start: -1,
(vma)? vma->vm_end: 0);
up_write(&mm->mmap_sem);
mmap_write_unlock(mm);
map = -ENOMEM;
goto out;
}
@ -2150,7 +2156,7 @@ static int remap_user_space(uintptr_t rva, size_t len, int prot)
prot, MAP_FIXED|MAP_SHARED, pgoff);
#endif
up_write(&mm->mmap_sem);
mmap_write_unlock(mm);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0)
map = vm_mmap(file, start, len,
@ -2175,7 +2181,7 @@ int mcctrl_clear_pte_range(uintptr_t start, uintptr_t len)
int ret;
ret = 0;
down_read(&mm->mmap_sem);
mmap_read_lock(mm);
addr = start;
while (addr < (start + len)) {
vma = find_vma(mm, addr);
@ -2193,7 +2199,7 @@ int mcctrl_clear_pte_range(uintptr_t start, uintptr_t len)
if (addr < end) {
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 18, 0)
/* Revert permission */
vma->vm_flags |= VM_READ | VM_WRITE | VM_EXEC;
vm_flags_set(vma, VM_READ | VM_WRITE | VM_EXEC);
error = zap_vma_ptes(vma, addr, end-addr);
if (error) {
mcctrl_zap_page_range(vma, addr, end-addr,
@ -2212,14 +2218,14 @@ int mcctrl_clear_pte_range(uintptr_t start, uintptr_t len)
}
else {
/* Revert permission */
vma->vm_flags |= VM_READ | VM_WRITE | VM_EXEC;
vm_flags_set(vma, VM_READ | VM_WRITE | VM_EXEC);
zap_vma_ptes(vma, addr, end-addr);
}
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(4, 18, 0) */
}
addr = end;
}
up_read(&mm->mmap_sem);
mmap_read_unlock(mm);
return ret;
}