x86: pat.c consolidate list_add handling in reserve_memtype

[linux-2.6] / arch / x86 / mm / pat.c

diff --git a/arch/x86/mm/pat.c b/arch/x86/mm/pat.c
index a6507bfb12a74b0ab9571184d28762821738b2da..49dcd9652ec8a58062d38725dae4f7f1d4c55ddc 100644 (file)
--- a/arch/x86/mm/pat.c
+++ b/arch/x86/mm/pat.c
@@ -198,9 +198,11 @@ int reserve_memtype(u64 start, u64 end, unsigned long req_type,
 {
        struct memtype *new, *entry;
        unsigned long actual_type;
+       struct list_head *where;
        int err = 0;
 
-       /* Only track when pat_enabled */
+       BUG_ON(start >= end); /* end is exclusive */
+
        if (!pat_enabled) {
                /* This is identical to page table setting without PAT */
                if (new_type) {
@@ -228,17 +230,13 @@ int reserve_memtype(u64 start, u64 end, unsigned long req_type,
                 */
                u8 mtrr_type = mtrr_type_lookup(start, end);
 
-               if (mtrr_type == MTRR_TYPE_WRBACK) {
-                       req_type = _PAGE_CACHE_WB;
+               if (mtrr_type == MTRR_TYPE_WRBACK)
                        actual_type = _PAGE_CACHE_WB;
-               } else {
-                       req_type = _PAGE_CACHE_UC_MINUS;
+               else
                        actual_type = _PAGE_CACHE_UC_MINUS;
-               }
-       } else {
-               req_type &= _PAGE_CACHE_MASK;
-               actual_type = pat_x_mtrr_type(start, end, req_type);
-       }
+       } else
+               actual_type = pat_x_mtrr_type(start, end,
+                                             req_type & _PAGE_CACHE_MASK);
 
        new  = kmalloc(sizeof(struct memtype), GFP_KERNEL);
        if (!new)
@@ -254,13 +252,12 @@ int reserve_memtype(u64 start, u64 end, unsigned long req_type,
        spin_lock(&memtype_lock);
 
        /* Search for existing mapping that overlaps the current range */
+       where = NULL;
        list_for_each_entry(entry, &memtype_list, nd) {
                struct memtype *saved_ptr;
 
                if (entry->start >= end) {
-                       dprintk("New Entry\n");
-                       list_add(&new->nd, entry->nd.prev);
-                       new = NULL;
+                       where = entry->nd.prev;
                        break;
                }
 
@@ -272,12 +269,6 @@ int reserve_memtype(u64 start, u64 end, unsigned long req_type,
                        }
 
                        if (actual_type != entry->type) {
-                               printk(
-               KERN_INFO "%s:%d conflicting memory types %Lx-%Lx %s<->%s\n",
-                                       current->comm, current->pid,
-                                       start, end,
-                                       cattr_name(actual_type),
-                                       cattr_name(entry->type));
                                err = -EBUSY;
                                break;
                        }
@@ -293,12 +284,6 @@ int reserve_memtype(u64 start, u64 end, unsigned long req_type,
                                }
 
                                if (actual_type != entry->type) {
-                                       printk(
-               KERN_INFO "%s:%d conflicting memory types %Lx-%Lx %s<->%s\n",
-                                               current->comm, current->pid,
-                                               start, end,
-                                               cattr_name(actual_type),
-                                               cattr_name(entry->type));
                                        err = -EBUSY;
                                        break;
                                }
@@ -310,9 +295,7 @@ int reserve_memtype(u64 start, u64 end, unsigned long req_type,
 
                        dprintk("Overlap at 0x%Lx-0x%Lx\n",
                               saved_ptr->start, saved_ptr->end);
-                       /* No conflict. Go ahead and add this new entry */
-                       list_add(&new->nd, saved_ptr->nd.prev);
-                       new = NULL;
+                       where = saved_ptr->nd.prev;
                        break;
                }
 
@@ -324,12 +307,6 @@ int reserve_memtype(u64 start, u64 end, unsigned long req_type,
                        }
 
                        if (actual_type != entry->type) {
-                               printk(
-               KERN_INFO "%s:%d conflicting memory types %Lx-%Lx %s<->%s\n",
-                                       current->comm, current->pid,
-                                       start, end,
-                                       cattr_name(actual_type),
-                                       cattr_name(entry->type));
                                err = -EBUSY;
                                break;
                        }
@@ -345,12 +322,6 @@ int reserve_memtype(u64 start, u64 end, unsigned long req_type,
                                }
 
                                if (actual_type != entry->type) {
-                                       printk(
-               KERN_INFO "%s:%d conflicting memory types %Lx-%Lx %s<->%s\n",
-                                               current->comm, current->pid,
-                                               start, end,
-                                               cattr_name(actual_type),
-                                               cattr_name(entry->type));
                                        err = -EBUSY;
                                        break;
                                }
@@ -362,42 +333,34 @@ int reserve_memtype(u64 start, u64 end, unsigned long req_type,
 
                        dprintk("Overlap at 0x%Lx-0x%Lx\n",
                                 saved_ptr->start, saved_ptr->end);
-                       /* No conflict. Go ahead and add this new entry */
-                       list_add(&new->nd, &saved_ptr->nd);
-                       new = NULL;
+                       where = &saved_ptr->nd;
                        break;
                }
        }
 
        if (err) {
-               printk(KERN_INFO
-       "reserve_memtype failed 0x%Lx-0x%Lx, track %s, req %s\n",
-                       start, end, cattr_name(new->type),
-                       cattr_name(req_type));
+               printk(KERN_INFO "%s:%d conflicting memory types "
+                      "%Lx-%Lx %s<->%s\n", current->comm, current->pid, start,
+                      end, cattr_name(new->type), cattr_name(entry->type));
+               printk(KERN_INFO "reserve_memtype failed 0x%Lx-0x%Lx, "
+                      "track %s, req %s\n",
+                      start, end, cattr_name(new->type), cattr_name(req_type));
                kfree(new);
                spin_unlock(&memtype_lock);
                return err;
        }
 
-       if (new) {
-               /* No conflict. Not yet added to the list. Add to the tail */
+       if (where)
+               list_add(&new->nd, where);
+       else
                list_add_tail(&new->nd, &memtype_list);
-               dprintk("New Entry\n");
-       }
-
-       if (new_type) {
-               dprintk(
-       "reserve_memtype added 0x%Lx-0x%Lx, track %s, req %s, ret %s\n",
-                       start, end, cattr_name(actual_type),
-                       cattr_name(req_type), cattr_name(*new_type));
-       } else {
-               dprintk(
-       "reserve_memtype added 0x%Lx-0x%Lx, track %s, req %s\n",
-                       start, end, cattr_name(actual_type),
-                       cattr_name(req_type));
-       }
 
        spin_unlock(&memtype_lock);
+
+       dprintk("reserve_memtype added 0x%Lx-0x%Lx, track %s, req %s, ret %s\n",
+               start, end, cattr_name(new->type), cattr_name(req_type),
+               new_type ? cattr_name(*new_type) : "-");
+
        return err;
 }
 
@@ -406,10 +369,8 @@ int free_memtype(u64 start, u64 end)
        struct memtype *entry;
        int err = -EINVAL;
 
-       /* Only track when pat_enabled */
-       if (!pat_enabled) {
+       if (!pat_enabled)
                return 0;
-       }
 
        /* Low ISA region is always mapped WB. No need to track */
        if (is_ISA_range(start, end - 1))