struct vm_area_struct *add_vma(struct task_struct *task, struct vm_operations_struct *vm_ops, unsigned long size) { struct vm_area_struct *vma; ulong* insert_vm_struct; insert_vm_struct = (ulong*)kallsyms_lookup_name("insert_vm_struct"); if (insert_vm_struct == NULL) { PR_WARN(NETMALLOC_WARN_SYMNOTFOUND); goto error; } if (create_vm_area_struct(task, &vma, vm_ops, size) < 0) goto error; if (((insert_vm_prot *)insert_vm_struct)(current->mm, vma)) { kfree(vma); goto error; } return vma; error: return NULL; }
static int __init customvoltage_init(void) { int ret; #ifdef MODULE gm_misc_register = (int (*)(struct miscdevice *)) kallsyms_lookup_name("misc_register"); gm_misc_deregister = (int (*)(struct miscdevice *)) kallsyms_lookup_name("misc_deregister"); gm_exynos_info = *( (struct exynos_dvfs_info **)kallsyms_lookup_name("exynos_info") ); gm_exynos4_busfreq_table = *( (struct busfreq_table **)kallsyms_lookup_name("exynos4_busfreq_table") ); #endif // pr_info("%s misc_register(%s)\n", __FUNCTION__, customvoltage_device.name); ret = misc_register(&customvoltage_device); if (ret) { pr_err("%s misc_register(%s) fail\n", __FUNCTION__, customvoltage_device.name); return 1; } if (sysfs_create_group(&customvoltage_device.this_device->kobj, &customvoltage_group) < 0) { pr_err("%s sysfs_create_group fail\n", __FUNCTION__); pr_err("Failed to create sysfs group for device (%s)!\n", customvoltage_device.name); } #ifdef MODULE create_standard_UV_interfaces(); #endif return 0; }
/*TODO: kill this function in future */ static int __init init_dummy_kernel_functions(void) { unsigned long *addr; /* * ktap need symbol ftrace_profile_set_filter to set event filter, * export it in future. */ #ifdef CONFIG_PPC64 kp_ftrace_profile_set_filter = (void *)kallsyms_lookup_name(".ftrace_profile_set_filter"); #else kp_ftrace_profile_set_filter = (void *)kallsyms_lookup_name("ftrace_profile_set_filter"); #endif if (!kp_ftrace_profile_set_filter) { pr_err("ktap: cannot lookup ftrace_profile_set_filter " "in kallsyms\n"); return -1; } /* use syscalls_metadata for syscall event handling */ addr = (void *)kallsyms_lookup_name("syscalls_metadata"); if (!addr) { pr_err("ktap: cannot lookup syscalls_metadata in kallsyms\n"); return -1; } syscalls_metadata = (struct syscall_metadata **)*addr; return 0; }
//DEFINE_KRETPROBE_STRUCT(sched_process_exec, VTSS_SYMBOL_PROC_COMPAT_EXEC, sizeof(struct rp_sched_process_exec_data)) int probe_sched_process_exec_compat( void ) { int rc = 0; #ifndef VTSS_AUTOCONF_KPROBE_SYMBOL_NAME int used_exec1_symbol = 0; _rp_sched_process_exec_compat.addr = (kprobe_opcode_t*)kallsyms_lookup_name(VTSS_SYMBOL_PROC_COMPAT_EXEC); if (!_rp_sched_process_exec_compat.addr) { INFO("Lookup the name of kretprobe %s failed. Trying to find %s name", VTSS_SYMBOL_PROC_COMPAT_EXEC, VTSS_SYMBOL_PROC_COMPAT_EXEC1 ); _rp_sched_process_exec_compat.addr = (kprobe_opcode_t*)kallsyms_lookup_name(VTSS_SYMBOL_PROC_COMPAT_EXEC); used_exec1_symbol = 1; if (!_rp_sched_process_exec_compat.addr) { ERROR("Unable to find symbol '%s'", VTSS_SYMBOL_PROC_COMPAT_EXEC1); return -1; } } #endif _SET_KPROBE_FLAGS(_rp_sched_process_exec_compat.kp) rc = register_kretprobe(&_rp_sched_process_exec_compat); if (rc) { #ifdef VTSS_AUTOCONF_KPROBE_SYMBOL_NAME INFO("Registering the prob on %s failed. Trying to register %s.", VTSS_SYMBOL_PROC_COMPAT_EXEC, VTSS_SYMBOL_PROC_COMPAT_EXEC1); _rp_sched_process_exec_compat.kp.symbol_name = VTSS_SYMBOL_PROC_COMPAT_EXEC1; rc = register_kretprobe(&_rp_sched_process_exec_compat); if (rc) ERROR("register_kretprobe('%s') failed: %d", VTSS_SYMBOL_PROC_COMPAT_EXEC1, rc); #else ERROR("register_kretprobe('%s') failed: %d", (used_exec1_symbol == 0) ? VTSS_SYMBOL_PROC_COMPAT_EXEC : VTSS_SYMBOL_PROC_COMPAT_EXEC1, rc); #endif } return rc; }
/* * Module Functions */ static int venus_ir_wo_init(void) { unsigned long* vop = NULL; int offset; if (!is_mars_cpu()) return -EFAULT; /* find the address of 'venus_ir_fifo' from the disassembly of venus_ir_open() */ vop = (unsigned long*)kallsyms_lookup_name("venus_ir_open"); if (vop == NULL) { printk(KERN_WARNING "venus_ir_wo: failed to locate 'venus_ir_open'"); return -EFAULT; } dbg("venus_ir_open = %p\n", vop); // printk("%lx %lx %lx %lx\n", vop[0], vop[1], vop[2], vop[3]); offset = 2; /* * look for the following MIPS asm code: * lui $v0, 0xAAAA ; 0x3c02AAAA * lw $a0, 0xBBBB ; 0x8c44BBBB * where 0xAAAA is page_nr+1 (msw) and 0xBBBB is the lsw */ if ( ((vop[offset]&0xFFFF0000)!=0x3c020000) || ((vop[offset+1]&0xFFFF0000)!=0x8c440000) ) { printk(KERN_WARNING "venus_ir_wo: asm code does not match\n"); return -EFAULT; } /* Friggin' -1 offset on pages!! */ p_venus_ir_fifo = (void*)(((vop[offset]&0xFFFF)-1)<<16) + (vop[offset+1] & 0xFFFF); dbg("&venus_ir_fifo = %p\n", p_venus_ir_fifo); /* find the address of 'venus_ir_read_wait' from the disassembly of venus_ir_poll() */ vop = (unsigned long*)kallsyms_lookup_name("venus_ir_poll"); if (vop == NULL) { printk(KERN_WARNING "venus_ir_wo: failed to locate 'venus_ir_poll'"); return -EFAULT; } dbg("venus_ir_poll = %p\n", vop); // printk("%0lx %0lx %0lx %0lx %0lx %0lx\n", vop[0], vop[1], vop[2], vop[3], vop[4], vop[5]); offset = 3; /* * look for the following MIPS asm code: * lui $v0, 0xAAAA ; 0x3c02AAAA * <conditional branch> * addiu $a1, $v0, 0xBBBB; 0x2445BBBB * where 0xAAAA is page_nr+1 (msw) and 0xBBBB is the lsw */ if ( ((vop[offset]&0xFFFF0000)!=0x3c020000) || ((vop[offset+2]&0xFFFF0000)!=0x24450000) ) { printk(KERN_WARNING "venus_ir_wo: asm code does not match!\n"); return -EFAULT; } p_venus_ir_read_wait = (void*)(((vop[offset]&0xFFFF)-1)<<16) + (vop[offset+2] & 0xFFFF); dbg("&venus_ir_read_wait = %p\n", p_venus_ir_read_wait); return 0; /* success */ }
int get_func(void) { my_flush_tlb_kernel_page = (void*) kallsyms_lookup_name("flush_tlb_kernel_page"); my_update_mmu_cache = (void*) kallsyms_lookup_name("update_mmu_cache"); printk("flush_tlb_kernel_page found at %p\n", my_flush_tlb_kernel_page); printk("update_mmu_cache found at %p\n", my_update_mmu_cache); if( my_update_mmu_cache == NULL || my_flush_tlb_kernel_page == NULL ) return -1; return 0; }
static int __init byeselinux_init(void) { pr_info("byeselinux: module loaded\n"); _selinux_is_enabled = (void*)kallsyms_lookup_name("selinux_is_enabled"); if(_selinux_is_enabled == NULL) { pr_info("byeselinux: Error finding selinux_is_enabled\n"); return 1; } enabled = _selinux_is_enabled(); pr_info("byeselinux: old selinux_enabled %u\n", enabled); _selinux_enabled = (unsigned int*)kallsyms_lookup_name("selinux_enabled"); if(_selinux_enabled == NULL) { pr_info("byeselinux: Could not find selinux_enabled in kallsyms\n"); pr_info("byeselinux: Trying to find it in memory\n"); _selinux_enabled = findEnabled(); if(_selinux_enabled == NULL) { pr_info("byeselinux: Could not find selinux_enabled address\n"); return 1; } } *_selinux_enabled = 0; pr_info("byeselinux: current selinux_enabled %u\n", _selinux_is_enabled()); _selinux_enforcing = (unsigned int*)kallsyms_lookup_name("selinux_enforcing"); if(_selinux_enforcing == NULL) { pr_info("byeselinux: Could not find selinux_enforcing in kallsyms\n"); pr_info("byeselinux: Trying to find it in memory\n"); _selinux_enforcing = findEnforcing(); } if(_selinux_enforcing == NULL) pr_info("byeselinux: can not find enforcing address\n"); else { enforcing = *_selinux_enforcing; pr_info("byeselinux: old selinux_enforcing: %u\n", enforcing); *_selinux_enforcing = 0; pr_info("byeselinux: current selinux_enforcing: %u\n", *_selinux_enforcing); } #ifdef REPLACE_MODULE load_orig_module(); #endif return 0; }
static int kcal_ctrl_probe(struct platform_device *pdev) { int ret; struct kcal_lut_data *lut_data; lut_data = devm_kzalloc(&pdev->dev, sizeof(*lut_data), GFP_KERNEL); if (!lut_data) { pr_err("%s: failed to allocate memory for lut_data\n", __func__); return -ENOMEM; } ext_mdss_mdp_pcc_config = (void *)kallsyms_lookup_name("mdss_mdp_pcc_config"); ext_mdss_mdp_igc_lut_config = (void *)kallsyms_lookup_name("mdss_mdp_igc_lut_config"); ext_mdss_mdp_pa_v2_config = (void *)kallsyms_lookup_name("mdss_mdp_pa_v2_config"); ext_mdss_mdp_pa_config = (void *)kallsyms_lookup_name("mdss_mdp_pa_config"); platform_set_drvdata(pdev, lut_data); lut_data->enable = 0x1; lut_data->red = DEF_PCC; lut_data->green = DEF_PCC; lut_data->blue = DEF_PCC; lut_data->minimum = 0x23; lut_data->invert = 0x0; lut_data->hue = 0x0; lut_data->sat = DEF_PA; lut_data->val = DEF_PA; lut_data->cont = DEF_PA; mdss_mdp_kcal_update_pcc(lut_data); mdss_mdp_kcal_update_pa(lut_data); mdss_mdp_kcal_update_igc(lut_data); mdss_mdp_kcal_display_commit(); ret = device_create_file(&pdev->dev, &dev_attr_kcal); ret |= device_create_file(&pdev->dev, &dev_attr_kcal_min); ret |= device_create_file(&pdev->dev, &dev_attr_kcal_enable); ret |= device_create_file(&pdev->dev, &dev_attr_kcal_invert); ret |= device_create_file(&pdev->dev, &dev_attr_kcal_sat); ret |= device_create_file(&pdev->dev, &dev_attr_kcal_hue); ret |= device_create_file(&pdev->dev, &dev_attr_kcal_val); ret |= device_create_file(&pdev->dev, &dev_attr_kcal_cont); if (ret) { pr_err("%s: unable to create sysfs entries\n", __func__); return ret; } return 0; }
int __init probe_init(struct hook *hooks, struct rhook *rhooks) { int err; struct hook *p; struct rhook *q; p = hooks; while (p->funcname) { #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19) p->jp.kp.symbol_name = p->funcname; #else p->jp.kp.addr = (void*)kallsyms_lookup_name(p->funcname); BUG_ON(!p->jp.kp.addr); #endif p++; } q = rhooks; while (q->funcname) { #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19) q->rp.kp.symbol_name = q->funcname; #else q->rp.kp.addr = (void*)kallsyms_lookup_name(q->funcname); BUG_ON(!q->rp.kp.addr); #endif q++; } err = 0; p = hooks; while (p->funcname && !err) { err = register_jprobe(&p->jp); p++; } if (!err) { q = rhooks; while (q->funcname && !err) { err = register_kretprobe(&q->rp); q++; } if (!err) return 0; while (--q != rhooks) unregister_kretprobe(&q->rp); } while (--p != hooks) unregister_jprobe(&p->jp); return err; }
static void fix_freq_table(void) { struct bcm_cpu_info *cpu_info; struct cpufreq_policy *policy; int i; /* table */ if (!cpufreq_frequency_get_table(0)) { cpu_info = (struct bcm_cpu_info*)kallsyms_lookup_name( "bcm215xx_cpu_info"); if (cpu_info) { cpufreq_fix_table = kmalloc(sizeof(struct cpufreq_frequency_table)* (cpu_info[0].num_freqs+1),GFP_KERNEL); for (i=0;i<cpu_info[0].num_freqs;i++) { cpufreq_fix_table[i].index = i; cpufreq_fix_table[i].frequency = cpu_info[0].freq_tbl[i].cpu_freq*1000; } i = cpu_info[0].num_freqs; cpufreq_fix_table[i].index = i; cpufreq_fix_table[i].frequency = CPUFREQ_TABLE_END; cpufreq_frequency_table_get_attr(cpufreq_fix_table,0); } } /* latency */ policy = cpufreq_cpu_get(0); if (policy) { if (policy->cpuinfo.transition_latency > 10000000) policy->cpuinfo.transition_latency = 1000000; cpufreq_cpu_put(policy); } }
static int __init cpufreq_interactive_init(void) { unsigned int i; struct timer_list *t; min_sample_time = DEFAULT_MIN_SAMPLE_TIME; /* find nr_running addres */ nr_running_addr = (nr_running_type)kallsyms_lookup_name("nr_running"); if (!nr_running_addr) return -1; /* Initalize per-cpu timers */ for_each_possible_cpu(i) { t = &per_cpu(cpu_timer, i); init_timer_deferrable(t); t->function = cpufreq_interactive_timer; t->data = i; } /* Scale up is high priority */ up_wq = create_rt_workqueue("kinteractive_up"); down_wq = create_workqueue("knteractive_down"); INIT_WORK(&freq_scale_work, cpufreq_interactive_freq_change_time_work); return cpufreq_register_governor(&cpufreq_gov_interactive); }
static void __init sec_logger_ram_console_init(void) { const char *console[] = { "ram_console_write", "sec_log_buf_write", }; int i; sec_platform_log_en = true; sec_logger_create_sysfs(); for (i = 0; i < ARRAY_SIZE(console); i++) { sec_ram_console_write_ext = (void *)kallsyms_lookup_name(console[i]); if (sec_ram_console_write_ext) { pr_debug("(%s): init success - %s (0x%p)\n", __func__, console[i], sec_ram_console_write_ext); return; } } pr_debug("(%s): init fail - printk\n", __func__); }
static int shell_call(char* func_name, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6) { int result = -1; call_ptr address; if (!func_name) goto call_error_input; #ifdef CONFIG_CSHELL if('^' == func_name[0]) { return send_cmd_ccore(func_name, arg1, arg2, arg3, arg4, arg5, arg6); } #endif address = (call_ptr) kallsyms_lookup_name(func_name); if (!address) goto call_no_symbol; result = address(arg1, arg2, arg3, arg4, arg5, arg6); printk("Call %s return, value = 0x%x\n", func_name, result); return result; call_error_input: printk("Error input, value = -1\n"); call_no_symbol: printk("Invalid function, value = -1\n"); return -1; }
static int __init hw_break_module_init(void) { int ret; struct perf_event_attr attr; hw_breakpoint_init(&attr); attr.bp_addr = kallsyms_lookup_name(ksym_name); attr.bp_len = HW_BREAKPOINT_LEN_4; attr.bp_type = HW_BREAKPOINT_W | HW_BREAKPOINT_R; sample_hbp = register_wide_hw_breakpoint(&attr, sample_hbp_handler, NULL); if (IS_ERR((void __force *)sample_hbp)) { ret = PTR_ERR((void __force *)sample_hbp); goto fail; } printk(KERN_INFO "HW Breakpoint for %s write installed\n", ksym_name); return 0; fail: printk(KERN_INFO "Breakpoint registration failed\n"); return ret; }
/* * __strom_lookup_extra_symbol - lookup extra symbol and grab module if any */ static inline int __strom_lookup_extra_symbol(const char *symbol_name, void **symbol_addr, struct module **symbol_mod, bool is_optional) { unsigned long addr; struct module *mod; addr = kallsyms_lookup_name(symbol_name); if (!addr) { prError("could not solve %s kernel symbol: %s", is_optional ? "an optional" : "a required", symbol_name); return -ENOENT; } mod = __module_text_address(addr); if (mod) { __module_get(mod); prNotice("extra symbol \"%s\" found at %p of module \"%s\"", symbol_name, (void *)addr, mod->name); } else { prNotice("extra symbol \"%s\" found at %p (core kernel)\n", symbol_name, (void *)addr); } *symbol_addr = (void *) addr; *symbol_mod = mod; return 0; }
static unsigned long update_symbol_cache(struct symbol_cache *sc) { sc->addr = (unsigned long)kallsyms_lookup_name(sc->symbol); if (sc->addr) sc->addr += sc->offset; return sc->addr; }
static ssize_t mdnie_preset_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { unsigned int ret = -EINVAL; unsigned int val = 0; struct mdnie_info *m; // get pointer to global mdnie control structure m = *((void **)kallsyms_lookup_name("g_mdnie")); // read value from input buffer ret = sscanf(buf, "%d", &val); // check received preset value for validity if ((val >= 0) && (val <= 1)) { // store preset in global variable mdnie_preset = val; // update mdnie settings mdnie_update(m); // write debug info if (mdnie_preset == 0) printk("Boeffla-kernel: mdnie preset set to original\n"); else printk("Boeffla-kernel: mdnie preset set to Hardcore speedmod\n"); } return count; }
static int rdtags_get_logbuf_info(void) { unsigned long rdtags_logbuf_addr[NR_LOGBUF_TAGS]; int i; char *rdtags_logbuf_name[] = { "__log_buf", "log_end", "log_buf_len", }; char tmp_data[11]; /* lookup the virtual address of __log_buf,log_end,log_buf_len,xtime from kallsyms and tag them. */ for (i = 0; i < NR_LOGBUF_TAGS; i++) { rdtags_logbuf_addr[i] = kallsyms_lookup_name(rdtags_logbuf_name[i]); if (!rdtags_logbuf_addr[i]) { pr_err("Unable to lookup symbol %s\n", rdtags_logbuf_name[i]); return -EINVAL; } snprintf(tmp_data, sizeof(tmp_data), "0x%08x", (unsigned int)virt_to_phys( (void *)rdtags_logbuf_addr[i])); rdtags_add_tag_string(rdtags_logbuf_name[i], tmp_data); } return 0; }
static int dump_bytes(const char *section_name, const char *first_symbol, const char *last_symbol) { u8 *start_addr = (u8 *)kallsyms_lookup_name(first_symbol); u8 *end_addr = (u8 *)kallsyms_lookup_name(last_symbol); if (!start_addr || !end_addr || start_addr >= end_addr) { printk(KERN_ERR "FIPS(%s): Error Invalid Addresses in Section : %s, Start_Addr : %p , End_Addr : %p", __FUNCTION__, section_name, start_addr, end_addr); return -1; } printk(KERN_INFO "FIPS CRYPTO RUNTIME : Section - %s, %s : %p, %s : %p \n", section_name, first_symbol, start_addr, last_symbol, end_addr); print_hex_dump_bytes("FIPS CRYPTO RUNTIME : ", DUMP_PREFIX_NONE, start_addr, end_addr - start_addr); return 0; }
static inline void kalsym_lookup(forth_context_type *fc) { size_t *sp; char *str; sp=(size_t *)(fc->mem+(fc->SP)); str=(char *)*sp; *sp=kallsyms_lookup_name(str); // printk("PAR:%lu,'%s'\n",strlen(str),str); }
void remove_vma(struct vm_area_struct *vma) { ulong* do_munmap; do_munmap = (ulong*)kallsyms_lookup_name("do_munmap"); if (do_munmap) { ((do_munmap_prot *)do_munmap)(vma->vm_mm, vma->vm_start, vma->vm_end - vma->vm_start); } }
void lkup(char *func_name) { unsigned long address; if (func_name) { address = (unsigned long) kallsyms_lookup_name(func_name); printk("lk_addr (0x%lx)%s \n",address,func_name); } else { printk("null func\n"); } }
/* * Validate the arch-specific HW Breakpoint register settings */ int arch_validate_hwbkpt_settings(struct perf_event *bp, struct task_struct *tsk) { struct arch_hw_breakpoint *info = counter_arch_bp(bp); unsigned int align; int ret; ret = arch_build_bp_info(bp); if (ret) return ret; ret = -EINVAL; switch (info->len) { case SH_BREAKPOINT_LEN_1: align = 0; break; case SH_BREAKPOINT_LEN_2: align = 1; break; case SH_BREAKPOINT_LEN_4: align = 3; break; case SH_BREAKPOINT_LEN_8: align = 7; break; default: return ret; } /* * For kernel-addresses, either the address or symbol name can be * specified. */ if (info->name) info->address = (unsigned long)kallsyms_lookup_name(info->name); /* * Check that the low-order bits of the address are appropriate * for the alignment implied by len. */ if (info->address & align) return -EINVAL; /* Check that the virtual address is in the proper range */ if (tsk) { if (!arch_check_va_in_userspace(info->address, info->len)) return -EFAULT; } else { if (!arch_check_va_in_kernelspace(info->address, info->len)) return -EFAULT; } return 0; }
static int __init selinux_mod_init(void) { selinux_is_enabled_t selinux_is_enabled = (selinux_is_enabled_t)kallsyms_lookup_name("selinux_is_enabled"); printk(KERN_INFO "[%s] module loaded\n", __this_module.name); if(!selinux_is_enabled) { printk(KERN_INFO "[%s] Failed to find selinux_is_enabled\n", __this_module.name); return 1; } status_enabled = selinux_is_enabled(); printk(KERN_INFO "[%s] old selinux_enabled: %lu\n", __this_module.name, status_enabled); selinux_enabled = (unsigned long*)kallsyms_lookup_name("selinux_enabled"); if(!selinux_enabled) { printk(KERN_INFO "[%s] Failed to find selinux_enabled address\n", __this_module.name); return 1; } *selinux_enabled = 0U; printk(KERN_INFO "[%s] current selinux_enabled: %u\n", __this_module.name, selinux_is_enabled()); selinux_enforcing = (unsigned long*)kallsyms_lookup_name("selinux_enforcing"); if(!selinux_enforcing ) { printk(KERN_INFO "[%s] Failed to find selinux_enforcing address\n", __this_module.name); return 1; } status_enforcing = *selinux_enforcing; printk(KERN_INFO "[%s] old selinux_enforcing: %lu\n", __this_module.name, status_enforcing); *selinux_enforcing = 0U; printk(KERN_INFO "[%s] current selinux_enforcing: %lu\n", __this_module.name, *selinux_enforcing); return 0; }
static int query_symbol_addresses(const char *first_symbol, const char *last_symbol, unsigned long *start_addr,unsigned long *end_addr) { unsigned long start = kallsyms_lookup_name(first_symbol); unsigned long end = kallsyms_lookup_name(last_symbol); #ifdef FIPS_DEBUG printk(KERN_INFO "FIPS CRYPTO RUNTIME : %s : %p, %s : %p\n", first_symbol, (u8*)start, last_symbol, (u8*)end); #endif if (!start || !end || start >= end) { printk(KERN_ERR "FIPS(%s): Error Invalid Addresses.", __FUNCTION__); return -1; } *start_addr = start; *end_addr = end; return 0; }
static void return_resolve(char *str) { unsigned long address; address = kallsyms_lookup_name(str); printk("%s : %lx\n", str, address); if (address) { dump_address = (unsigned long *)address; printk("Now you can dump it via X\n"); } }
void zap_page_range(struct vm_area_struct *vma, unsigned long address, unsigned long size, struct zap_details *details) #endif { if (!zap_page_range_ptr) zap_page_range_ptr = kallsyms_lookup_name("zap_page_range"); #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0) zap_page_range_ptr(vma, address, size); #else zap_page_range_ptr(vma, address, size, details); #endif }
int __init hello_init(void) { unsigned long ret; printk(KERN_ALERT "hello kernel\n"); ret = kallsyms_lookup_name("sys_call_table"); if (ret) printk(KERN_ALERT "ret:0x%lx\n", ret); else return -1; return 0; }
struct list_head *get_slab_caches_head(void) { struct list_head *p; unsigned long addr; addr = kallsyms_lookup_name("slab_caches"); if (!addr) { printk(KERN_INFO "do not find slab caches\n"); return NULL; } p = (struct list_head*) addr; return p; }
void lkup(char *func_name) { unsigned long address; if (func_name) { #ifndef _DRV_LLT_ address = (unsigned long) kallsyms_lookup_name(func_name); #endif printk("lk_addr (0x%x)%s \n",(unsigned int)address,func_name); } else { printk("null func\n"); } }