*/
 
 /* Policies */
-#define MPOL_DEFAULT   0
-#define MPOL_PREFERRED 1
-#define MPOL_BIND      2
-#define MPOL_INTERLEAVE        3
-
-#define MPOL_MAX MPOL_INTERLEAVE
+enum {
+       MPOL_DEFAULT,
+       MPOL_PREFERRED,
+       MPOL_BIND,
+       MPOL_INTERLEAVE,
+       MPOL_MAX,       /* always last member of enum */
+};
 
 /* Flags for get_mem_policy */
 #define MPOL_F_NODE    (1<<0)  /* return next IL mode instead of node mask */
  */
 struct mempolicy {
        atomic_t refcnt;
-       short policy;   /* See MPOL_* above */
+       unsigned short policy;  /* See MPOL_* above */
        union {
                short            preferred_node; /* preferred */
                nodemask_t       nodes;         /* interleave/bind */
        spinlock_t lock;
 };
 
-void mpol_shared_policy_init(struct shared_policy *info, int policy,
+void mpol_shared_policy_init(struct shared_policy *info, unsigned short policy,
                                nodemask_t *nodes);
 int mpol_set_shared_policy(struct shared_policy *info,
                                struct vm_area_struct *vma,
 }
 
 static inline void mpol_shared_policy_init(struct shared_policy *info,
-                                       int policy, nodemask_t *nodes)
+                               unsigned short policy, nodemask_t *nodes)
 {
 }
 
 
                                const nodemask_t *newmask);
 
 /* Do sanity checking on a policy */
-static int mpol_check_policy(int mode, nodemask_t *nodes)
+static int mpol_check_policy(unsigned short mode, nodemask_t *nodes)
 {
        int was_empty, is_empty;
 
                if (!was_empty && is_empty)
                        return -EINVAL;
                break;
+       default:
+               BUG();
        }
        return 0;
 }
 }
 
 /* Create a new policy */
-static struct mempolicy *mpol_new(int mode, nodemask_t *nodes)
+static struct mempolicy *mpol_new(unsigned short mode, nodemask_t *nodes)
 {
        struct mempolicy *policy;
 
                }
                policy->v.nodes = *nodes;
                break;
+       default:
+               BUG();
        }
        policy->policy = mode;
        policy->cpuset_mems_allowed = cpuset_mems_allowed(current);
 }
 
 /* Set the process memory policy */
-static long do_set_mempolicy(int mode, nodemask_t *nodes)
+static long do_set_mempolicy(unsigned short mode, nodemask_t *nodes)
 {
        struct mempolicy *new;
 
 #endif
 
 static long do_mbind(unsigned long start, unsigned long len,
-                    unsigned long mode, nodemask_t *nmask,
+                    unsigned short mode, nodemask_t *nmask,
                     unsigned long flags)
 {
        struct vm_area_struct *vma;
        int err;
        LIST_HEAD(pagelist);
 
-       if ((flags & ~(unsigned long)(MPOL_MF_STRICT |
-                                     MPOL_MF_MOVE | MPOL_MF_MOVE_ALL))
-           || mode > MPOL_MAX)
+       if (flags & ~(unsigned long)(MPOL_MF_STRICT |
+                                    MPOL_MF_MOVE | MPOL_MF_MOVE_ALL))
                return -EINVAL;
        if ((flags & MPOL_MF_MOVE_ALL) && !capable(CAP_SYS_NICE))
                return -EPERM;
        if (!new)
                flags |= MPOL_MF_DISCONTIG_OK;
 
-       pr_debug("mbind %lx-%lx mode:%ld nodes:%lx\n",start,start+len,
+       pr_debug("mbind %lx-%lx mode:%d nodes:%lx\n", start, start + len,
                 mode, nmask ? nodes_addr(*nmask)[0] : -1);
 
        down_write(&mm->mmap_sem);
        nodemask_t nodes;
        int err;
 
+       if (mode >= MPOL_MAX)
+               return -EINVAL;
        err = get_nodes(&nodes, nmask, maxnode);
        if (err)
                return err;
        int err;
        nodemask_t nodes;
 
-       if (mode < 0 || mode > MPOL_MAX)
+       if (mode < 0 || mode >= MPOL_MAX)
                return -EINVAL;
        err = get_nodes(&nodes, nmask, maxnode);
        if (err)
  */
 unsigned slab_node(struct mempolicy *policy)
 {
-       int pol = policy ? policy->policy : MPOL_DEFAULT;
+       unsigned short pol = policy ? policy->policy : MPOL_DEFAULT;
 
        switch (pol) {
        case MPOL_INTERLEAVE:
        return 0;
 }
 
-void mpol_shared_policy_init(struct shared_policy *info, int policy,
+void mpol_shared_policy_init(struct shared_policy *info, unsigned short policy,
                                nodemask_t *policy_nodes)
 {
        info->root = RB_ROOT;
        char *p = buffer;
        int l;
        nodemask_t nodes;
-       int mode = pol ? pol->policy : MPOL_DEFAULT;
+       unsigned short mode = pol ? pol->policy : MPOL_DEFAULT;
 
        switch (mode) {
        case MPOL_DEFAULT:
 
 
 #ifdef CONFIG_NUMA
 #ifdef CONFIG_TMPFS
-static int shmem_parse_mpol(char *value, int *policy, nodemask_t *policy_nodes)
+static int shmem_parse_mpol(char *value, unsigned short *policy,
+                           nodemask_t *policy_nodes)
 {
        char *nodelist = strchr(value, ':');
        int err = 1;
        return err;
 }
 
-static void shmem_show_mpol(struct seq_file *seq, int policy,
+static void shmem_show_mpol(struct seq_file *seq, unsigned short policy,
                            const nodemask_t policy_nodes)
 {
        char *policy_string;
 }
 #else /* !CONFIG_NUMA */
 #ifdef CONFIG_TMPFS
-static inline int shmem_parse_mpol(char *value, int *policy,
+static inline int shmem_parse_mpol(char *value, unsigned short *policy,
                                                nodemask_t *policy_nodes)
 {
        return 1;
 }
 
-static inline void shmem_show_mpol(struct seq_file *seq, int policy,
+static inline void shmem_show_mpol(struct seq_file *seq, unsigned short policy,
                            const nodemask_t policy_nodes)
 {
 }