#include <asm/uaccess.h>
#include <ksyms/ksyms.h>
+#include <master/swap_initializer.h>
#include "device_driver.h"
#include "swap_driver_errors.h"
#define MAXIMUM_SUBBUFFER_SIZE (64 * 1024)
/* swap_device driver routines */
-static int swap_device_open(struct inode *inode, struct file *filp);
-static int swap_device_release(struct inode *inode, struct file *file);
static ssize_t swap_device_read(struct file *filp, char __user *buf,
size_t count, loff_t *f_pos);
static long swap_device_ioctl(struct file *filp, unsigned int cmd,
const struct file_operations swap_device_fops = {
.owner = THIS_MODULE,
.read = swap_device_read,
- .open = swap_device_open,
- .release = swap_device_release,
+ .open = swap_init_simple_open,
+ .release = swap_init_simple_release,
.unlocked_ioctl = swap_device_ioctl,
.splice_read = swap_device_splice_read,
};
unregister_chrdev_region(swap_device_no, 1);
}
-static int swap_device_open(struct inode *inode, struct file *filp)
-{
- // TODO MOD_INC_USE_COUNT
- return 0;
-}
-
-static int swap_device_release(struct inode *inode, struct file *filp)
-{
- // TODO MOD_DEC_USE_COUNT
- return 0;
-}
-
static ssize_t swap_device_read(struct file *filp, char __user *buf,
size_t count, loff_t *f_pos)
{
*/
#include <linux/module.h>
-
+#include <master/swap_initializer.h>
#include "driver_defs.h"
#include "device_driver.h"
#include "us_interaction.h"
-static int __init swap_driver_init(void)
+static int fs_init(void)
{
int ret;
return ret;
}
-static void __exit swap_driver_exit(void)
+static void fs_uninit(void)
{
us_interaction_destroy();
swap_device_exit();
print_msg("Driver module uninitialized\n");
}
-module_init(swap_driver_init);
-module_exit(swap_driver_exit);
+SWAP_LIGHT_INIT_MODULE(NULL, NULL, NULL, fs_init, fs_uninit);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("SWAP device driver");
#include <linux/math64.h>
#include <master/swap_debugfs.h>
#include "energy.h"
+#include "debugfs_energy.h"
#include "rational_debugfs.h"
#include "lcd/lcd_debugfs.h"
return 0;
}
-DEFINE_SIMPLE_ATTRIBUTE(fops_get_u64, get_func_u64, NULL, "%llu\n");
+SWAP_DEFINE_SIMPLE_ATTRIBUTE(fops_get_u64, get_func_u64, NULL, "%llu\n");
struct param_data {
*/
+#include <linux/fs.h>
+#include <master/swap_initializer.h>
+
+
struct dentry;
+/* based on define DEFINE_SIMPLE_ATTRIBUTE */
+#define SWAP_DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt) \
+static int __fops ## _open(struct inode *inode, struct file *file) \
+{ \
+ int ret; \
+ \
+ ret = swap_init_simple_open(inode, file); \
+ if (ret) \
+ return ret; \
+ \
+ __simple_attr_check_format(__fmt, 0ull); \
+ ret = simple_attr_open(inode, file, __get, __set, __fmt); \
+ if (ret) \
+ swap_init_simple_release(inode, file); \
+ \
+ return ret; \
+} \
+static int __fops ## _release(struct inode *inode, struct file *file) \
+{ \
+ simple_attr_release(inode, file); \
+ swap_init_simple_release(inode, file); \
+ \
+ return 0; \
+} \
+static const struct file_operations __fops = { \
+ .owner = THIS_MODULE, \
+ .open = __fops ## _open, \
+ .release = __fops ## _release, \
+ .read = simple_attr_read, \
+ .write = simple_attr_write, \
+ .llseek = generic_file_llseek, \
+}
+
+
int init_debugfs_energy(void);
void exit_debugfs_energy(void);
}
EXPORT_SYMBOL_GPL(unset_energy);
+int energy_once(void)
+{
+ const char *sym;
+
+ sym = "__switch_to";
+ switch_to_krp.kp.addr = (kprobe_opcode_t *)swap_ksyms(sym);
+ if (switch_to_krp.kp.addr == NULL)
+ goto not_found;
+
+ sym = "sys_read";
+ sys_read_krp.kp.addr = (kprobe_opcode_t *)swap_ksyms(sym);
+ if (sys_read_krp.kp.addr == NULL)
+ goto not_found;
+
+ sym = "sys_write";
+ sys_write_krp.kp.addr = (kprobe_opcode_t *)swap_ksyms(sym);
+ if (sys_write_krp.kp.addr == NULL)
+ goto not_found;
+
+ return 0;
+
+not_found:
+ printk("ERROR: symbol '%s' not found\n", sym);
+ return -ESRCH;
+}
/**
* @brief Initialization energy
int energy_init(void)
{
int ret;
- unsigned long addr;
-
- addr = swap_ksyms("__switch_to");
- if (addr == 0) {
- printk("Cannot find address for __switch_to function!\n");
- return -EINVAL;
- }
- switch_to_krp.kp.addr = (kprobe_opcode_t *)addr;
-
- addr = swap_ksyms("sys_read");
- if (addr == 0) {
- printk("Cannot find address for sys_read function!\n");
- return -EINVAL;
- }
- sys_read_krp.kp.addr = (kprobe_opcode_t *)addr;
-
- addr = swap_ksyms("sys_write");
- if (addr == 0) {
- printk("Cannot find address for sys_write function!\n");
- return -EINVAL;
- }
- sys_write_krp.kp.addr = (kprobe_opcode_t *)addr;
ret = init_feature();
if (ret) {
};
+int energy_once(void);
int energy_init(void);
void energy_uninit(void);
#include <linux/module.h>
+#include <master/swap_initializer.h>
#include "energy.h"
#include "debugfs_energy.h"
-static int __init swap_energy_init(void)
-{
- int ret;
-
- ret = init_debugfs_energy();
- if (ret) {
- printk("Cannot init debugfs for energy\n");
- return ret;
- }
-
- ret = energy_init();
- if (ret) {
- printk("Cannot init energy\n");
- exit_debugfs_energy();
- }
-
- return ret;
-}
-
-static void __exit swap_energy_exit(void)
-{
- energy_uninit();
- exit_debugfs_energy();
-}
-
-module_init(swap_energy_init);
-module_exit(swap_energy_exit);
+SWAP_LIGHT_INIT_MODULE(energy_once, energy_init, energy_uninit,
+ init_debugfs_energy, exit_debugfs_energy);
MODULE_LICENSE("GPL");
#include <linux/module.h>
#include <linux/slab.h>
#include <energy/lcd/lcd_base.h>
+#include <energy/debugfs_energy.h>
#include <energy/rational_debugfs.h>
return 0;
}
-DEFINE_SIMPLE_ATTRIBUTE(fops_get_system, get_system, NULL, "%llu\n");
+SWAP_DEFINE_SIMPLE_ATTRIBUTE(fops_get_system, get_system, NULL, "%llu\n");
static struct dentry *lcd_dir = NULL;
#include <linux/dcache.h>
#include <linux/debugfs.h>
#include <linux/module.h>
+#include "debugfs_energy.h"
#include "rational_debugfs.h"
return 0;
}
-DEFINE_SIMPLE_ATTRIBUTE(fops_denom, denom_get, denom_set, "%llu\n");
+SWAP_DEFINE_SIMPLE_ATTRIBUTE(fops_denom, denom_get, denom_set, "%llu\n");
/**
* @brief Create file in debugfs for rational struct
}
}
-int mem_rwx_init(void)
+int mem_rwx_once(void)
{
const char *sym;
#define _MEMORY_RWX_H
-int mem_rwx_init(void);
-void mem_rwx_exit(void) {};
+int mem_rwx_once(void);
void mem_rwx_write_u32(unsigned long addr, unsigned long val);
};
/**
- * @brief Initializes kprobes module for ARM arch.
+ * @brief Arch-dependend module deps initialization stub.
*
- * @return 0 on success, error code on error.
+ * @return 0.
*/
-int swap_arch_init_kprobes(void)
+int arch_init_module_deps(void)
{
+ const char *sym;
+#ifdef CONFIG_STRICT_MEMORY_RWX
int ret;
-#ifdef CONFIG_STRICT_MEMORY_RWX
- ret = mem_rwx_init();
+ ret = mem_rwx_once();
if (ret)
return ret;
#endif /* CONFIG_STRICT_MEMORY_RWX */
- // Register hooks (kprobe_handler)
- __swap_register_undef_hook = (void *)swap_ksyms("register_undef_hook");
- if (__swap_register_undef_hook == NULL) {
- printk("no register_undef_hook symbol found!\n");
- return -1;
- }
+ sym = "register_undef_hook";
+ __swap_register_undef_hook = (void *)swap_ksyms(sym);
+ if (__swap_register_undef_hook == NULL)
+ goto not_found;
+
+ sym = "unregister_undef_hook";
+ __swap_unregister_undef_hook = (void *)swap_ksyms(sym);
+ if (__swap_unregister_undef_hook == NULL)
+ goto not_found;
+
+ return 0;
+
+not_found:
+ printk("ERROR: symbol '%s' not found\n", sym);
+ return -ESRCH;
+}
- // Unregister hooks (kprobe_handler)
- __swap_unregister_undef_hook = (void *)swap_ksyms("unregister_undef_hook");
- if (__swap_unregister_undef_hook == NULL) {
- printk("no unregister_undef_hook symbol found!\n");
- return -1;
- }
+/**
+ * @brief Initializes kprobes module for ARM arch.
+ *
+ * @return 0 on success, error code on error.
+ */
+int swap_arch_init_kprobes(void)
+{
+ int ret;
swap_register_undef_hook(&undef_ho_k);
{
kjump_exit();
swap_unregister_undef_hook(&undef_ho_k);
-
-#ifdef CONFIG_STRICT_MEMORY_RWX
- mem_rwx_exit();
-#endif /* CONFIG_STRICT_MEMORY_RWX */
}
/* export symbol for trampoline_arm.h */
void swap_register_undef_hook(struct undef_hook *hook);
void swap_unregister_undef_hook(struct undef_hook *hook);
-/**
- * @brief Arch-dependend module deps initialization stub.
- *
- * @return 0.
- */
-static inline int arch_init_module_deps(void)
-{
- return 0;
-}
+int arch_init_module_deps(void);
int arch_make_trampoline_arm(unsigned long addr, unsigned long insn,
unsigned long *tramp);
#include <linux/pagemap.h>
#include <ksyms/ksyms.h>
+#include <master/swap_initializer.h>
#include <swap-asm/swap_kprobes.h>
#include "swap_slots.h"
return arch_init_module_deps();
}
-static int __init init_kprobes(void)
+static int once(void)
{
- int i, err = 0;
+ int i, ret;
+ const char *sym;
- module_alloc = (void *)swap_ksyms("module_alloc");
- if (!module_alloc) {
- printk("module_alloc is not found! Oops.\n");
- return -1;
- }
- module_free = (void *)swap_ksyms("module_free");
- if (!module_alloc) {
- printk("module_free is not found! Oops.\n");
- return -1;
- }
+ sym = "module_alloc";
+ module_alloc = (void *)swap_ksyms(sym);
+ if (module_alloc == NULL)
+ goto not_found;
- init_sm();
+ sym = "module_free";
+ module_free = (void *)swap_ksyms(sym);
+ if (module_alloc == NULL)
+ goto not_found;
+
+ ret = init_module_deps();
+ if (ret)
+ return ret;
- /* FIXME allocate the probe table, currently defined statically */
- /* initialize all list heads */
+ /*
+ * FIXME allocate the probe table, currently defined statically
+ * initialize all list heads
+ */
for (i = 0; i < KPROBE_TABLE_SIZE; ++i) {
INIT_HLIST_HEAD(&kprobe_table[i]);
INIT_HLIST_HEAD(&kretprobe_inst_table[i]);
}
- atomic_set(&kprobe_count, 0);
- err = init_module_deps();
- if (err) {
- return err;
- }
+ return 0;
+
+not_found:
+ printk("ERROR: symbol '%s' not found\n", sym);
+ return -ESRCH;
+}
- err = swap_arch_init_kprobes();
+static int init_kprobes(void)
+{
+ init_sm();
+ atomic_set(&kprobe_count, 0);
- return err;
+ return swap_arch_init_kprobes();
}
-static void __exit exit_kprobes(void)
+static void exit_kprobes(void)
{
swap_arch_exit_kprobes();
exit_sm();
}
-module_init(init_kprobes);
-module_exit(exit_kprobes);
+SWAP_LIGHT_INIT_MODULE(once, init_kprobes, exit_kprobes, NULL, NULL);
MODULE_LICENSE("GPL");
#include <asm/errno.h>
#include <ksyms/ksyms.h>
#include <kprobe/swap_kprobes.h>
+#include <master/swap_initializer.h>
#include <writer/swap_writer_module.h>
#include <writer/event_filter.h>
#include "ks_features.h"
}
}
-static int __init init_ks_feature(void)
+
+static int once(void)
{
int ret;
return ret;
ret = init_syscall_features();
- if (ret)
- exit_switch_context();
return ret;
}
-static void __exit exit_ks_feature(void)
+static void core_uninit(void)
{
uninit_syscall_features();
exit_switch_context();
}
-module_init(init_ks_feature);
-module_exit(exit_ks_feature);
+SWAP_LIGHT_INIT_MODULE(once, NULL, core_uninit, NULL, NULL);
MODULE_LICENSE("GPL");
*
* @return 0.
*/
-int init_features(void)
+int once_features(void)
{
int i;
for (i = 0; i < SIZE_FEATURE_LIST; ++i) {
return 0;
}
-/**
- * @brief Uninits features list.
- *
- * @return Void.
- */
-void uninit_features(void)
-{
-}
-
static int do_set_features(struct conf_data *conf)
{
int i, ret;
struct conf_data;
-int init_features(void);
-void uninit_features(void);
+int once_features(void);
int set_features(struct conf_data *conf);
*
* @return Initialization results.
*/
-int init_cmd(void)
+int once_cmd(void)
{
- int ret;
-
- ret = init_features();
-
- return ret;
-}
-
-/**
- * @brief Uninitializes commands handling.
- *
- * @return Void.
- */
-void uninit_cmd(void)
-{
- uninit_features();
+ return once_features();
}
struct msg_buf;
-int init_cmd(void);
-void uninit_cmd(void);
+int once_cmd(void);
int msg_keep_alive(struct msg_buf *mb);
int msg_start(struct msg_buf *mb);
#include <driver/driver_to_msg.h>
#include <driver/swap_ioctl.h>
+#include <master/swap_initializer.h>
/**
* @enum MSG_ID
return ret;
}
-static void register_msg_handler(void)
+static int reg_msg_handler(void)
{
set_msg_handler(msg_handler);
+ return 0;
}
-static void unregister_msg_handler(void)
+static void unreg_msg_handler(void)
{
set_msg_handler(NULL);
}
-static int __init swap_parser_init(void)
+static int once(void)
{
int ret;
- ret = init_cpu_deps();
+ ret = once_cmd();
if (ret)
- goto out;
-
- register_msg_handler();
+ return ret;
- ret = init_cmd();
+ ret = init_cpu_deps();
-out:
return ret;
}
-static void __exit swap_parser_exit(void)
-{
- uninit_cmd();
- unregister_msg_handler();
-}
-
-module_init(swap_parser_init);
-module_exit(swap_parser_exit);
+SWAP_LIGHT_INIT_MODULE(once, reg_msg_handler, unreg_msg_handler, NULL, NULL);
MODULE_LICENSE("GPL");
#include <linux/mempolicy.h>
#include <linux/module.h>
+#include <master/swap_initializer.h>
#include <kprobe/swap_slots.h>
#include <kprobe/swap_kdebug.h>
#include <kprobe/swap_kprobes_deps.h>
}
EXPORT_SYMBOL_GPL(swap_ujprobe_return);
-static int __init init_uprobes(void)
+static int once(void)
{
init_uprobe_table();
init_uprobes_insn_slots();
init_uretprobe_inst_table();
- return swap_arch_init_uprobes();
-}
-
-static void __exit exit_uprobes(void)
-{
- swap_arch_exit_uprobes();
+ return 0;
}
-module_init(init_uprobes);
-module_exit(exit_uprobes);
+SWAP_LIGHT_INIT_MODULE(once, swap_arch_init_uprobes, swap_arch_exit_uprobes,
+ NULL, NULL);
MODULE_LICENSE ("GPL");
#include <linux/module.h>
#include <master/swap_debugfs.h>
+#include <master/swap_initializer.h>
#include <us_manager/sspt/sspt_proc.h>
#include "debugfs_us_manager.h"
static const struct file_operations fops_tasks = {
.owner = THIS_MODULE,
+ .open = swap_init_simple_open,
+ .release = swap_init_simple_release,
.read = read_tasks,
.llseek = default_llseek
};
*
* @return Error code
*/
-int init_helper(void)
+int once_helper(void)
{
- unsigned long addr;
+ const char *sym;
#ifdef CONFIG_ARM
- addr = swap_ksyms("do_page_fault");
+ sym = "do_page_fault";
#else /* CONFIG_ARM */
- addr = swap_ksyms("handle_mm_fault");
+ sym = "handle_mm_fault";
#endif /* CONFIG_ARM */
+ mf_kretprobe.kp.addr = (kprobe_opcode_t *)swap_ksyms(sym);
+ if (mf_kretprobe.kp.addr == NULL)
+ goto not_found;
- if (addr == 0) {
- printk("Cannot find address for handle_mm_fault function!\n");
- return -EINVAL;
- }
- mf_kretprobe.kp.addr = (kprobe_opcode_t *)addr;
+ sym = "copy_process";
+ cp_kretprobe.kp.addr = (kprobe_opcode_t *)swap_ksyms_substr(sym);
+ if (cp_kretprobe.kp.addr == NULL)
+ goto not_found;
- addr = swap_ksyms_substr("copy_process");
- if (addr == 0) {
- printk("Cannot find address for copy_process function!\n");
- return -EINVAL;
- }
- cp_kretprobe.kp.addr = (kprobe_opcode_t *)addr;
- addr = swap_ksyms("mm_release");
- if (addr == 0) {
- printk("Cannot find address for mm_release function!\n");
- return -EINVAL;
- }
- mr_kprobe.addr = (kprobe_opcode_t *)addr;
+ sym = "mm_release";
+ mr_kprobe.addr = (kprobe_opcode_t *)swap_ksyms(sym);
+ if (mr_kprobe.addr == NULL)
+ goto not_found;
- addr = swap_ksyms("do_munmap");
- if (addr == 0) {
- printk("Cannot find address for do_munmap function!\n");
- return -EINVAL;
- }
- unmap_kretprobe.kp.addr = (kprobe_opcode_t *)addr;
+ sym = "do_munmap";
+ unmap_kretprobe.kp.addr = (kprobe_opcode_t *)swap_ksyms(sym);
+ if (unmap_kretprobe.kp.addr == NULL)
+ goto not_found;
- addr = swap_ksyms("do_mmap_pgoff");
- if (addr == 0) {
- printk("Cannot find address for do_mmap_pgoff function!\n");
- return -EINVAL;
- }
- mmap_kretprobe.kp.addr = (kprobe_opcode_t *)addr;
+ sym = "do_mmap_pgoff";
+ mmap_kretprobe.kp.addr = (kprobe_opcode_t *)swap_ksyms(sym);
+ if (mmap_kretprobe.kp.addr == NULL)
+ goto not_found;
- addr = swap_ksyms("set_task_comm");
- if (addr == 0) {
- printk("Cannot find address for set_task_comm function!\n");
- return -EINVAL;
- }
- comm_kretprobe.kp.addr = (kprobe_opcode_t *)addr;
+ sym = "set_task_comm";
+ comm_kretprobe.kp.addr = (kprobe_opcode_t *)swap_ksyms(sym);
+ if (comm_kretprobe.kp.addr == NULL)
+ goto not_found;
#ifdef CONFIG_ARM
- addr = swap_ksyms("ret_to_user");
- if (addr == 0) {
- printk("Cannot find address for ret_to_user function!\n");
- return -EINVAL;
- }
- ctx_task_kprobe.addr = (kprobe_opcode_t *)addr;
+ sym = "ret_to_user";
+ ctx_task_kprobe.addr = (kprobe_opcode_t *)swap_ksyms(sym);
+ if (ctx_task_kprobe.addr == NULL)
+ goto not_found;
#endif /* CONFIG_ARM */
return 0;
-}
-/**
- * @brief Uninitialization of helper
- *
- * @return Void
- */
-void uninit_helper(void)
-{
+not_found:
+ printk("ERROR: symbol '%s' not found\n", sym);
+ return -ESRCH;
}
return !task->mm;
}
-int init_helper(void);
-void uninit_helper(void);
+int once_helper(void);
int register_helper(void);
void unregister_helper_top(void);
#include "debugfs_us_manager.h"
#include <writer/event_filter.h>
+#include <master/swap_initializer.h>
/* FIXME: move /un/init_msg() elsewhere and remove this include */
#include <writer/swap_writer_module.h> /* for /un/init_msg() */
-static int __init init_us_manager(void)
+static int init_us_manager(void)
{
int ret;
ret = init_us_filter();
if (ret)
- goto us_filter_init_fail;
-
- init_msg(32*1024);
-
- ret = init_helper();
- if (ret)
- goto helper_init_fail;
+ return ret;
- ret = init_debugfs_us_manager();
+ ret = init_msg(32*1024); /* TODO: move to writer */
if (ret)
- goto debugfs_init_fail;
-
- return 0;
+ exit_us_filter();
-debugfs_init_fail:
- uninit_helper();
-
-helper_init_fail:
- uninit_msg();
- exit_us_filter();
-
-us_filter_init_fail:
return ret;
}
-static void __exit exit_us_manager(void)
+static void exit_us_manager(void)
{
if (status == ST_ON)
do_usm_stop();
- exit_debugfs_us_manager();
uninit_msg();
- uninit_helper();
exit_us_filter();
}
-module_init(init_us_manager);
-module_exit(exit_us_manager);
+SWAP_LIGHT_INIT_MODULE(once_helper, init_us_manager, exit_us_manager,
+ init_debugfs_us_manager, exit_debugfs_us_manager);
MODULE_LICENSE ("GPL");
-
#include <linux/slab.h>
#include <asm/uaccess.h>
#include <master/swap_debugfs.h>
+#include <master/swap_initializer.h>
#include "swap_writer_module.h"
#include "event_filter.h"
static const struct file_operations fops_raw = {
.owner = THIS_MODULE,
+ .open = swap_init_simple_open,
+ .release = swap_init_simple_release,
.write = write_raw,
.llseek = default_llseek
};
static const struct file_operations fops_available_filters = {
.owner = THIS_MODULE,
+ .open = swap_init_simple_open,
+ .release = swap_init_simple_release,
.read = read_af,
.llseek = default_llseek
};
static const struct file_operations fops_filter = {
.owner = THIS_MODULE,
+ .open = swap_init_simple_open,
+ .release = swap_init_simple_release,
.read = read_filter,
.write = write_filter,
.llseek = default_llseek
#include <asm/uaccess.h>
+#include <master/swap_initializer.h>
#include <buffer/swap_buffer_module.h>
#include <buffer/swap_buffer_errors.h>
}
EXPORT_SYMBOL_GPL(custom_exit_event);
-static int __init swap_writer_module_init(void)
-{
- int ret;
-
- ret = event_filter_init();
- if (ret)
- return ret;
-
- ret = init_debugfs_writer();
- if (ret)
- event_filter_exit();
-
- return ret;
-}
-
-static void __exit swap_writer_module_exit(void)
-{
- exit_debugfs_writer();
- event_filter_exit();
-}
-
-module_init(swap_writer_module_init);
-module_exit(swap_writer_module_exit);
+SWAP_LIGHT_INIT_MODULE(NULL, event_filter_init, event_filter_exit,
+ init_debugfs_writer, exit_debugfs_writer);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("SWAP Writer module");
projects / platform / kernel / swap-modules.git / commitdiff