[PATCH] Fix conflict with the is_init identifier on parisc

This appears to be the only usage of is_init in the kernel besides the
usage in sched.h.  On ia64 the same function is called in_init.  So to
remove the conflict and make the kernel more consistent rename is_init
is_core is_local and is_local_section to in_init in_core in_local and
in_local_section respectively.

Thanks to Adrian Bunk who spotted this, and to Matthew Wilcox
who suggested this fix.

Signed-off-by: Eric Biederman <ebiederm@xmission.com>
Cc: Kyle McMartin <kyle@mcmartin.ca>
Cc: Matthew Wilcox <willy@debian.org>
Cc: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

1 files changed, 16 insertions, 16 deletions

diff --git a/arch/parisc/kernel/module.c b/arch/parisc/kernel/module.c
index aee311884f3f..f50b982b0834 100644
--- a/arch/parisc/kernel/module.c
+++ b/arch/parisc/kernel/module.c
@@ -27,7 +27,7 @@
  *    - SEGREL32 handling
  *      We are not doing SEGREL32 handling correctly. According to the ABI, we
  *      should do a value offset, like this:
- *                      if (is_init(me, (void *)val))
+ *                      if (in_init(me, (void *)val))
  *                              val -= (uint32_t)me->module_init;
  *                      else
  *                              val -= (uint32_t)me->module_core;
@@ -72,27 +72,27 @@
 
 /* three functions to determine where in the module core
  * or init pieces the location is */
-static inline int is_init(struct module *me, void *loc)
+static inline int in_init(struct module *me, void *loc)
 {
         return (loc >= me->module_init &&
                 loc <= (me->module_init + me->init_size));
 }
 
-static inline int is_core(struct module *me, void *loc)
+static inline int in_core(struct module *me, void *loc)
 {
         return (loc >= me->module_core &&
                 loc <= (me->module_core + me->core_size));
 }
 
-static inline int is_local(struct module *me, void *loc)
+static inline int in_local(struct module *me, void *loc)
 {
-        return is_init(me, loc) || is_core(me, loc);
+        return in_init(me, loc) || in_core(me, loc);
 }
 
-static inline int is_local_section(struct module *me, void *loc, void *dot)
+static inline int in_local_section(struct module *me, void *loc, void *dot)
 {
-        return (is_init(me, loc) && is_init(me, dot)) ||
-                (is_core(me, loc) && is_core(me, dot));
+        return (in_init(me, loc) && in_init(me, dot)) ||
+                (in_core(me, loc) && in_core(me, dot));
 }
 
 
@@ -566,14 +566,14 @@ int apply_relocate_add(Elf_Shdr *sechdrs,
                         break;
                 case R_PARISC_PCREL17F:
                         /* 17-bit PC relative address */
-                        val = get_stub(me, val, addend, ELF_STUB_GOT, is_init(me, loc));
+                        val = get_stub(me, val, addend, ELF_STUB_GOT, in_init(me, loc));
                         val = (val - dot - 8)/4;
                         CHECK_RELOC(val, 17)
                         *loc = (*loc & ~0x1f1ffd) | reassemble_17(val);
                         break;
                 case R_PARISC_PCREL22F:
                         /* 22-bit PC relative address; only defined for pa20 */
-                        val = get_stub(me, val, addend, ELF_STUB_GOT, is_init(me, loc));
+                        val = get_stub(me, val, addend, ELF_STUB_GOT, in_init(me, loc));
                         DEBUGP("STUB FOR %s loc %lx+%lx at %lx\n", 
                                strtab + sym->st_name, (unsigned long)loc, addend, 
                                val)
@@ -670,9 +670,9 @@ int apply_relocate_add(Elf_Shdr *sechdrs,
                                strtab + sym->st_name,
                                loc, val);
                         /* can we reach it locally? */
-                        if(!is_local_section(me, (void *)val, (void *)dot)) {
+                        if(!in_local_section(me, (void *)val, (void *)dot)) {
 
-                                if (is_local(me, (void *)val))
+                                if (in_local(me, (void *)val))
                                         /* this is the case where the
                                          * symbol is local to the
                                          * module, but in a different
@@ -680,14 +680,14 @@ int apply_relocate_add(Elf_Shdr *sechdrs,
                                          * in case it's more than 22
                                          * bits away */
                                         val = get_stub(me, val, addend, ELF_STUB_DIRECT,
-                                                       is_init(me, loc));
+                                                       in_init(me, loc));
                                 else if (strncmp(strtab + sym->st_name, "$$", 2)
                                     == 0)
                                         val = get_stub(me, val, addend, ELF_STUB_MILLI,
-                                                       is_init(me, loc));
+                                                       in_init(me, loc));
                                 else
                                         val = get_stub(me, val, addend, ELF_STUB_GOT,
-                                                       is_init(me, loc));
+                                                       in_init(me, loc));
                         }
                         DEBUGP("STUB FOR %s loc %lx, val %lx+%lx at %lx\n", 
                                strtab + sym->st_name, loc, sym->st_value,
@@ -720,7 +720,7 @@ int apply_relocate_add(Elf_Shdr *sechdrs,
                         break;
                 case R_PARISC_FPTR64:
                         /* 64-bit function address */
-                        if(is_local(me, (void *)(val + addend))) {
+                        if(in_local(me, (void *)(val + addend))) {
                                 *loc64 = get_fdesc(me, val+addend);
                                 DEBUGP("FDESC for %s at %p points to %lx\n",
                                        strtab + sym->st_name, *loc64,