module: use a structure to encapsulate layout.

Makes it easier to handle init vs core cleanly, though the change is
fairly invasive across random architectures.

It simplifies the rbtree code immediately, however, while keeping the
core data together in the same cachline (now iff the rbtree code is
enabled).

Acked-by: Peter Zijlstra <peterz@infradead.org>
Reviewed-by: Josh Poimboeuf <jpoimboe@redhat.com>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>

1 files changed, 29 insertions, 35 deletions

diff --git a/include/linux/module.h b/include/linux/module.h
index 3a19c79918e0..6e68e8cf4d0d 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -302,6 +302,28 @@ struct mod_tree_node {
         struct latch_tree_node node;
 };
 
+struct module_layout {
+        /* The actual code + data. */
+        void *base;
+        /* Total size. */
+        unsigned int size;
+        /* The size of the executable code.  */
+        unsigned int text_size;
+        /* Size of RO section of the module (text+rodata) */
+        unsigned int ro_size;
+
+#ifdef CONFIG_MODULES_TREE_LOOKUP
+        struct mod_tree_node mtn;
+#endif
+};
+
+#ifdef CONFIG_MODULES_TREE_LOOKUP
+/* Only touch one cacheline for common rbtree-for-core-layout case. */
+#define __module_layout_align ____cacheline_aligned
+#else
+#define __module_layout_align
+#endif
+
 struct module {
         enum module_state state;
 
@@ -366,37 +388,9 @@ struct module {
         /* Startup function. */
         int (*init)(void);
 
-        /*
-         * If this is non-NULL, vfree() after init() returns.
-         *
-         * Cacheline align here, such that:
-         *   module_init, module_core, init_size, core_size,
-         *   init_text_size, core_text_size and mtn_core::{mod,node[0]}
-         * are on the same cacheline.
-         */
-        void *module_init       ____cacheline_aligned;
-
-        /* Here is the actual code + data, vfree'd on unload. */
-        void *module_core;
-
-        /* Here are the sizes of the init and core sections */
-        unsigned int init_size, core_size;
-
-        /* The size of the executable code in each section.  */
-        unsigned int init_text_size, core_text_size;
-
-#ifdef CONFIG_MODULES_TREE_LOOKUP
-        /*
-         * We want mtn_core::{mod,node[0]} to be in the same cacheline as the
-         * above entries such that a regular lookup will only touch one
-         * cacheline.
-         */
-        struct mod_tree_node    mtn_core;
-        struct mod_tree_node    mtn_init;
-#endif
-
-        /* Size of RO sections of the module (text+rodata) */
-        unsigned int init_ro_size, core_ro_size;
+        /* Core layout: rbtree is accessed frequently, so keep together. */
+        struct module_layout core_layout __module_layout_align;
+        struct module_layout init_layout;
 
         /* Arch-specific module values */
         struct mod_arch_specific arch;
@@ -505,15 +499,15 @@ bool is_module_text_address(unsigned long addr);
 static inline bool within_module_core(unsigned long addr,
                                       const struct module *mod)
 {
-        return (unsigned long)mod->module_core <= addr &&
-               addr < (unsigned long)mod->module_core + mod->core_size;
+        return (unsigned long)mod->core_layout.base <= addr &&
+               addr < (unsigned long)mod->core_layout.base + mod->core_layout.size;
 }
 
 static inline bool within_module_init(unsigned long addr,
                                       const struct module *mod)
 {
-        return (unsigned long)mod->module_init <= addr &&
-               addr < (unsigned long)mod->module_init + mod->init_size;
+        return (unsigned long)mod->init_layout.base <= addr &&
+               addr < (unsigned long)mod->init_layout.base + mod->init_layout.size;
 }
 
 static inline bool within_module(unsigned long addr, const struct module *mod)