Beispiel #1
1
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;
}
Beispiel #3
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;
}
Beispiel #5
0
/*
* 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 */
}
Beispiel #6
0
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;
}
Beispiel #7
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;
}
Beispiel #9
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;
}
Beispiel #10
0
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);
}
Beispiel #12
0
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;
}
Beispiel #15
0
/*
 * __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;
}
Beispiel #16
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;
}
Beispiel #17
0
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;
}
Beispiel #20
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);
}
Beispiel #21
0
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);
        }
}
Beispiel #22
0
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;
}
Beispiel #24
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;
}
Beispiel #26
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");
	}
}
Beispiel #27
0
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
}
Beispiel #28
0
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;
}
Beispiel #29
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");
	}
}