return result;
}
-EXPORT_SYMBOL_GPL(swap_buffer_init);
int swap_buffer_uninit(void)
return E_SB_SUCCESS;
}
-EXPORT_SYMBOL_GPL(swap_buffer_uninit);
ssize_t swap_buffer_write(void *data, size_t size)
return result;
}
-EXPORT_SYMBOL_GPL(swap_buffer_write);
int swap_buffer_get(struct swap_subbuffer **subbuffer)
return result;
}
-EXPORT_SYMBOL_GPL(swap_buffer_get);
int swap_buffer_release(struct swap_subbuffer **subbuffer)
return E_SB_SUCCESS;
}
-EXPORT_SYMBOL_GPL(swap_buffer_release);
unsigned int swap_buffer_flush(void)
return result;
}
-EXPORT_SYMBOL_GPL(swap_buffer_flush);
int swap_buffer_callback(void *buffer)
{
msg_handler = mh;
}
-EXPORT_SYMBOL_GPL(set_msg_handler);
{
return swap_dir;
}
-EXPORT_SYMBOL_GPL(get_swap_debugfs_dir);
int swap_debugfs_init(void)
{
return ret;
}
-EXPORT_SYMBOL_GPL(set_energy);
int unset_energy(void)
{
return ret;
}
-EXPORT_SYMBOL_GPL(unset_energy);
int energy_init(void)
{
return 0;
}
-EXPORT_SYMBOL_GPL(arch_make_trampoline_arm);
int arch_prepare_kprobe(struct kprobe *p, struct slot_manager *sm)
{
regs->ARM_pc = (unsigned long)p->ainsn.insn;
}
}
-EXPORT_SYMBOL_GPL(prepare_singlestep);
void save_previous_kprobe(struct kprobe_ctlblk *kcb, struct kprobe *p_run)
{
{
return 0;
}
-EXPORT_SYMBOL_GPL(longjmp_break_handler);
#ifdef CONFIG_STRICT_MEMORY_RWX
extern void mem_text_write_kernel_word(unsigned long *addr, unsigned long word);
{
__swap_register_undef_hook(hook);
}
-EXPORT_SYMBOL_GPL(swap_register_undef_hook);
void swap_unregister_undef_hook(struct undef_hook *hook)
{
__swap_unregister_undef_hook(hook);
}
-EXPORT_SYMBOL_GPL(swap_unregister_undef_hook);
// kernel probes hook
static struct undef_hook undef_ho_k = {
return (opcode != 0x2e && opcode != 0x9a);
}
}
-EXPORT_SYMBOL_GPL(can_boost);
/*
* returns non-zero if opcode modifies the interrupt flag.
regs->EREG (ip) = (unsigned long) p->ainsn.insn;
}
}
-EXPORT_SYMBOL_GPL(prepare_singlestep);
void save_previous_kprobe (struct kprobe_ctlblk *kcb, struct kprobe *cur_p)
{
return chunk_allocate(&fa->chunk, sm->slot_size);
}
-EXPORT_SYMBOL_GPL(alloc_insn_slot);
void free_insn_slot(struct slot_manager *sm, void *slot)
{
panic("free_insn_slot: slot=%p is not data base\n", slot);
}
-EXPORT_SYMBOL_GPL(free_insn_slot);
static struct hlist_head kretprobe_inst_table[KPROBE_TABLE_SIZE];
atomic_t kprobe_count;
-EXPORT_SYMBOL_GPL(kprobe_count);
static void *(*module_alloc)(unsigned long size) = NULL;
return NULL;
}
-EXPORT_SYMBOL_GPL(get_free_rp_inst);
/* Called with kretprobe_lock held */
struct kretprobe_instance *get_free_rp_inst_no_alloc(struct kretprobe *rp)
return NULL;
}
-EXPORT_SYMBOL_GPL(get_used_rp_inst);
/* Called with kretprobe_lock held */
void add_rp_inst (struct kretprobe_instance *ri)
INIT_HLIST_NODE(&ri->uflist);
hlist_add_head(&ri->uflist, &ri->rp->used_instances);
}
-EXPORT_SYMBOL_GPL(add_rp_inst);
/* Called with kretprobe_lock held */
void recycle_rp_inst(struct kretprobe_instance *ri)
hlist_add_head(&ri->uflist, &ri->rp->free_instances);
}
}
-EXPORT_SYMBOL_GPL(recycle_rp_inst);
struct hlist_head *kretprobe_inst_table_head(void *hash_key)
{
return &kretprobe_inst_table[hash_ptr(hash_key, KPROBE_HASH_BITS)];
}
-EXPORT_SYMBOL_GPL(kretprobe_inst_table_head);
void free_rp_inst(struct kretprobe *rp)
{
kfree(ri);
}
}
-EXPORT_SYMBOL_GPL(free_rp_inst);
/*
* Keep all fields in the kprobe consistent
return ret;
}
-EXPORT_SYMBOL_GPL(register_aggr_kprobe);
static void remove_kprobe(struct kprobe *p)
{
return clone;
}
-EXPORT_SYMBOL_GPL(clone_kretprobe);
static void inline rm_task_trampoline(struct task_struct *p, struct kretprobe_instance *ri)
{
arch_exit_kprobes();
exit_sm();
}
-EXPORT_SYMBOL_GPL(dbi_register_kprobe);
-EXPORT_SYMBOL_GPL(dbi_unregister_kprobe);
-EXPORT_SYMBOL_GPL(dbi_register_jprobe);
-EXPORT_SYMBOL_GPL(dbi_unregister_jprobe);
-EXPORT_SYMBOL_GPL(dbi_jprobe_return);
-EXPORT_SYMBOL_GPL(dbi_register_kretprobe);
-EXPORT_SYMBOL_GPL(dbi_unregister_kretprobes);
-EXPORT_SYMBOL_GPL(dbi_unregister_kretprobe);
out:
return 0;
}
-
-
-EXPORT_SYMBOL_GPL (page_present);
-EXPORT_SYMBOL_GPL (access_process_vm_atomic);
-
return install_features(f);
}
-EXPORT_SYMBOL_GPL(set_feature);
int unset_feature(enum feature_id id)
{
return uninstall_features(f);
}
-EXPORT_SYMBOL_GPL(unset_feature);
static int init_syscall_features(void)
{
free_probe(p);
return ret;
}
-EXPORT_SYMBOL_GPL(ksm_register_probe);
static void do_ksm_unregister_probe(struct probe *p)
{
return 0;
}
-EXPORT_SYMBOL_GPL(ksm_unregister_probe);
int ksm_unregister_probe_all(void)
{
return 0;
}
-EXPORT_SYMBOL_GPL(ksm_unregister_probe_all);
int init_ks_manager(void)
{
return sym_data.addr;
}
-EXPORT_SYMBOL_GPL(swap_ksyms_substr);
return ret;
}
-EXPORT_SYMBOL_GPL(swap_get_ksyms);
void swap_put_ksyms(void)
{
up(&cnt_init_sm_lock);
}
-EXPORT_SYMBOL_GPL(swap_put_ksyms);
unsigned long swap_ksyms(const char *name)
{
return 0;
}
-EXPORT_SYMBOL_GPL(swap_ksyms);
unsigned long swap_ksyms_substr(const char *name)
{
return 0;
}
-EXPORT_SYMBOL_GPL(swap_ksyms_substr);
int ksyms_init(void)
{
return ret;
}
-EXPORT_SYMBOL_GPL(swap_sampler_start);
int swap_sampler_stop(void)
{
return ret;
}
-EXPORT_SYMBOL_GPL(swap_sampler_stop);
int sampler_init(void)
{
"tgid=%u, addr=%p!\n", task->tgid, p->addr);
}
}
-EXPORT_SYMBOL_GPL(disarm_uprobe);
static void init_uprobes_insn_slots(void)
{
}
}
}
-EXPORT_SYMBOL_GPL(__dbi_unregister_uprobe);
void dbi_unregister_uprobe(struct uprobe *up)
{
hlist_del_rcu(&jp->up.kp.is_hlist);
}
}
-EXPORT_SYMBOL_GPL(__dbi_unregister_ujprobe);
void dbi_unregister_ujprobe(struct ujprobe *jp)
{
return 0;
}
-EXPORT_SYMBOL_GPL(dbi_disarm_urp_inst_for_task);
void __dbi_unregister_uretprobe(struct uretprobe *rp, int disarm)
{
spin_unlock_irqrestore(&uretprobe_lock, flags);
free_urp_inst(rp);
}
-EXPORT_SYMBOL_GPL(__dbi_unregister_uretprobe);
void dbi_unregister_uretprobe(struct uretprobe *rp)
{
{
arch_ujprobe_return();
}
-EXPORT_SYMBOL_GPL(swap_ujprobe_return);
int init_uprobes(void)
{
swap_arch_exit_uprobes();
}
-EXPORT_SYMBOL_GPL(dbi_register_ujprobe);
-EXPORT_SYMBOL_GPL(dbi_unregister_ujprobe);
-EXPORT_SYMBOL_GPL(dbi_register_uretprobe);
-EXPORT_SYMBOL_GPL(dbi_unregister_uretprobe);
-EXPORT_SYMBOL_GPL(dbi_unregister_all_uprobes);
return pfg;
}
-EXPORT_SYMBOL_GPL(get_pf_group_by_dentry);
struct pf_group *get_pf_group_by_tgid(pid_t tgid, void *priv)
{
return pfg;
}
-EXPORT_SYMBOL_GPL(get_pf_group_by_tgid);
struct pf_group *get_pf_group_dumb(void *priv)
{
return pfg;
}
-EXPORT_SYMBOL_GPL(get_pf_group_dumb);
void put_pf_group(struct pf_group *pfg)
{
{
return img_proc_add_ip(pfg->i_proc, dentry, offset, args, ret_type);
}
-EXPORT_SYMBOL_GPL(pf_register_probe);
int pf_unregister_probe(struct pf_group *pfg, struct dentry *dentry,
unsigned long offset)
{
return img_proc_del_ip(pfg->i_proc, dentry, offset);
}
-EXPORT_SYMBOL_GPL(pf_unregister_probe);
void call_page_fault(struct task_struct *task, unsigned long page_addr)
{
{
img_proc_print(pfg->i_proc);
}
-EXPORT_SYMBOL_GPL(pfg_print);
/* debug */
return NULL;
}
-EXPORT_SYMBOL_GPL(sspt_get_feature_data);
sspt_feature_id_t sspt_register_feature(void *(*alloc)(void), void (*free)(void *data))
{
return (sspt_feature_id_t)fi;
}
-EXPORT_SYMBOL_GPL(sspt_register_feature);
void sspt_unregister_feature(sspt_feature_id_t id)
{
on_each_proc(del_feature_from_proc, (void *)fi);
destroy_feature_img(fi);
}
-EXPORT_SYMBOL_GPL(sspt_unregister_feature);
return NULL;
}
-EXPORT_SYMBOL_GPL(sspt_proc_get_by_task);
void on_each_proc_no_lock(void (*func)(struct sspt_proc *, void *), void *data)
{
on_each_proc_no_lock(func, data);
spin_unlock(&proc_lock);
}
-EXPORT_SYMBOL_GPL(on_each_proc);
void wait_proc_lock(void)
{
mutex_lock(&mutex_inst);
return status;
}
-EXPORT_SYMBOL_GPL(usm_get_status);
void usm_put_status(enum status_type st)
{
status = st;
mutex_unlock(&mutex_inst);
}
-EXPORT_SYMBOL_GPL(usm_put_status);
int usm_stop(void)
{
return ret;
}
-EXPORT_SYMBOL_GPL(usm_stop);
int usm_start(void)
{
return ret;
}
-EXPORT_SYMBOL_GPL(usm_start);
{
quiet = q;
}
-EXPORT_SYMBOL_GPL(set_quiet);
enum quiet_type get_quiet(void)
{
return quiet;
}
-EXPORT_SYMBOL_GPL(get_quiet);
return 0;
}
-EXPORT_SYMBOL_GPL(event_filter_register);
void event_filter_unregister(struct ev_filter *f)
{
}
}
}
-EXPORT_SYMBOL_GPL(event_filter_unregister);
int event_filter_set(const char *name)
{
return 0;
}
-EXPORT_SYMBOL_GPL(event_filter_set);
const char *event_filter_get(void)
{
return E_SW_SUCCESS;
}
-EXPORT_SYMBOL_GPL(init_msg);
void uninit_msg(void)
{
for (i = 0; i < NR_CPUS; ++i)
kfree(cpu_buf[i]);
}
-EXPORT_SYMBOL_GPL(uninit_msg);
void reset_discarded(void)
{
discarded = 0;
}
-EXPORT_SYMBOL_GPL(reset_discarded);
void reset_seq_num(void)
{
seq_num = 0;
}
-EXPORT_SYMBOL_GPL(reset_seq_num);
unsigned int get_discarded_count(void)
{
return discarded;
}
-EXPORT_SYMBOL_GPL(get_discarded_count);
static inline char *get_current_buf(void)
{
return ret;
}
-EXPORT_SYMBOL_GPL(proc_info_msg);
write_to_buffer(buf);
put_current_buf();
}
-EXPORT_SYMBOL_GPL(terminate_msg);
write_to_buffer(buf);
put_current_buf();
}
-EXPORT_SYMBOL_GPL(pcoc_map_msg);
write_to_buffer(buf);
put_current_buf();
}
-EXPORT_SYMBOL_GPL(proc_unmap_msg);
return ret;
}
-EXPORT_SYMBOL_GPL(sample_msg);
return ret;
}
-EXPORT_SYMBOL_GPL(entry_event);
return ret;
}
-EXPORT_SYMBOL_GPL(exit_event);
return context_switch(regs, MSG_CONTEXT_SWITCH_ENTRY);
}
-EXPORT_SYMBOL_GPL(switch_entry);
int switch_exit(struct pt_regs *regs)
{
return context_switch(regs, MSG_CONTEXT_SWITCH_EXIT);
}
-EXPORT_SYMBOL_GPL(switch_exit);
return ret;
}
-EXPORT_SYMBOL_GPL(error_msg);
projects / kernel / swap-modules.git / commitdiff