lkdtm: prefix enum constants

Prefix cname and ctype constants with CN/CT_.  This is especially for the
conflict on BUG which causes a build break if arch defines it as a inline
function, i.e.  MIPS.

Signed-off-by: Namhyung Kim <namhyung@gmail.com>
Cc: Ankita Garg <ankita@in.ibm.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 64 insertions, 64 deletions

diff --git a/drivers/misc/lkdtm.c b/drivers/misc/lkdtm.c
index 343b5d8ea697..81d7fa4ec0db 100644
--- a/drivers/misc/lkdtm.c
+++ b/drivers/misc/lkdtm.c
@@ -52,32 +52,32 @@
 #define REC_NUM_DEFAULT 10
 
 enum cname {
-        INVALID,
-        INT_HARDWARE_ENTRY,
-        INT_HW_IRQ_EN,
-        INT_TASKLET_ENTRY,
-        FS_DEVRW,
-        MEM_SWAPOUT,
-        TIMERADD,
-        SCSI_DISPATCH_CMD,
-        IDE_CORE_CP,
-        DIRECT,
+        CN_INVALID,
+        CN_INT_HARDWARE_ENTRY,
+        CN_INT_HW_IRQ_EN,
+        CN_INT_TASKLET_ENTRY,
+        CN_FS_DEVRW,
+        CN_MEM_SWAPOUT,
+        CN_TIMERADD,
+        CN_SCSI_DISPATCH_CMD,
+        CN_IDE_CORE_CP,
+        CN_DIRECT,
 };
 
 enum ctype {
-        NONE,
-        PANIC,
-        BUG,
-        EXCEPTION,
-        LOOP,
-        OVERFLOW,
-        CORRUPT_STACK,
-        UNALIGNED_LOAD_STORE_WRITE,
-        OVERWRITE_ALLOCATION,
-        WRITE_AFTER_FREE,
-        SOFTLOCKUP,
-        HARDLOCKUP,
-        HUNG_TASK,
+        CT_NONE,
+        CT_PANIC,
+        CT_BUG,
+        CT_EXCEPTION,
+        CT_LOOP,
+        CT_OVERFLOW,
+        CT_CORRUPT_STACK,
+        CT_UNALIGNED_LOAD_STORE_WRITE,
+        CT_OVERWRITE_ALLOCATION,
+        CT_WRITE_AFTER_FREE,
+        CT_SOFTLOCKUP,
+        CT_HARDLOCKUP,
+        CT_HUNG_TASK,
 };
 
 static char* cp_name[] = {
@@ -117,8 +117,8 @@ static char* cpoint_type;
 static int cpoint_count = DEFAULT_COUNT;
 static int recur_count = REC_NUM_DEFAULT;
 
-static enum cname cpoint = INVALID;
-static enum ctype cptype = NONE;
+static enum cname cpoint = CN_INVALID;
+static enum ctype cptype = CT_NONE;
 static int count = DEFAULT_COUNT;
 
 module_param(recur_count, int, 0644);
@@ -207,12 +207,12 @@ static enum ctype parse_cp_type(const char *what, size_t count)
                         return i + 1;
         }
 
-        return NONE;
+        return CT_NONE;
 }
 
 static const char *cp_type_to_str(enum ctype type)
 {
-        if (type == NONE || type < 0 || type > ARRAY_SIZE(cp_type))
+        if (type == CT_NONE || type < 0 || type > ARRAY_SIZE(cp_type))
                 return "None";
 
         return cp_type[type - 1];
@@ -220,7 +220,7 @@ static const char *cp_type_to_str(enum ctype type)
 
 static const char *cp_name_to_str(enum cname name)
 {
-        if (name == INVALID || name < 0 || name > ARRAY_SIZE(cp_name))
+        if (name == CN_INVALID || name < 0 || name > ARRAY_SIZE(cp_name))
                 return "INVALID";
 
         return cp_name[name - 1];
@@ -245,7 +245,7 @@ static int lkdtm_parse_commandline(void)
                 return -EINVAL;
 
         cptype = parse_cp_type(cpoint_type, strlen(cpoint_type));
-        if (cptype == NONE)
+        if (cptype == CT_NONE)
                 return -EINVAL;
 
         for (i = 0; i < ARRAY_SIZE(cp_name); i++) {
@@ -274,30 +274,30 @@ static int recursive_loop(int a)
 static void lkdtm_do_action(enum ctype which)
 {
         switch (which) {
-        case PANIC:
+        case CT_PANIC:
                 panic("dumptest");
                 break;
-        case BUG:
+        case CT_BUG:
                 BUG();
                 break;
-        case EXCEPTION:
+        case CT_EXCEPTION:
                 *((int *) 0) = 0;
                 break;
-        case LOOP:
+        case CT_LOOP:
                 for (;;)
                         ;
                 break;
-        case OVERFLOW:
+        case CT_OVERFLOW:
                 (void) recursive_loop(0);
                 break;
-        case CORRUPT_STACK: {
+        case CT_CORRUPT_STACK: {
                 volatile u32 data[8];
                 volatile u32 *p = data;
 
                 p[12] = 0x12345678;
                 break;
         }
-        case UNALIGNED_LOAD_STORE_WRITE: {
+        case CT_UNALIGNED_LOAD_STORE_WRITE: {
                 static u8 data[5] __attribute__((aligned(4))) = {1, 2,
                                 3, 4, 5};
                 u32 *p;
@@ -309,7 +309,7 @@ static void lkdtm_do_action(enum ctype which)
                 *p = val;
                  break;
         }
-        case OVERWRITE_ALLOCATION: {
+        case CT_OVERWRITE_ALLOCATION: {
                 size_t len = 1020;
                 u32 *data = kmalloc(len, GFP_KERNEL);
 
@@ -317,7 +317,7 @@ static void lkdtm_do_action(enum ctype which)
                 kfree(data);
                 break;
         }
-        case WRITE_AFTER_FREE: {
+        case CT_WRITE_AFTER_FREE: {
                 size_t len = 1024;
                 u32 *data = kmalloc(len, GFP_KERNEL);
 
@@ -326,21 +326,21 @@ static void lkdtm_do_action(enum ctype which)
                 memset(data, 0x78, len);
                 break;
         }
-        case SOFTLOCKUP:
+        case CT_SOFTLOCKUP:
                 preempt_disable();
                 for (;;)
                         cpu_relax();
                 break;
-        case HARDLOCKUP:
+        case CT_HARDLOCKUP:
                 local_irq_disable();
                 for (;;)
                         cpu_relax();
                 break;
-        case HUNG_TASK:
+        case CT_HUNG_TASK:
                 set_current_state(TASK_UNINTERRUPTIBLE);