mm/slub: Convert check_object() to struct slab

Also convert check_bytes_and_report() and check_pad_bytes().
This is almost exclusively pushing slab_page() calls down.

Signed-off-by: Matthew Wilcox (Oracle) <willy@infradead.org>

diff --git a/mm/slub.c b/mm/slub.c
index eb4286886c3ea36f79bbd79d0e2130e1bd7198e4..fd11ca47bce89c48f2b47d4d2b1f5d3b447860d6 100644 (file)
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -904,13 +904,13 @@ static void restore_bytes(struct kmem_cache *s, char *message, u8 data,
        memset(from, data, to - from);
 }
 
-static int check_bytes_and_report(struct kmem_cache *s, struct page *page,
+static int check_bytes_and_report(struct kmem_cache *s, struct slab *slab,
                        u8 *object, char *what,
                        u8 *start, unsigned int value, unsigned int bytes)
 {
        u8 *fault;
        u8 *end;
-       u8 *addr = page_address(page);
+       u8 *addr = slab_address(slab);
 
        metadata_access_enable();
        fault = memchr_inv(kasan_reset_tag(start), value, bytes);
@@ -929,7 +929,7 @@ static int check_bytes_and_report(struct kmem_cache *s, struct page *page,
        pr_err("0x%p-0x%p @offset=%tu. First byte 0x%x instead of 0x%x\n",
                                        fault, end - 1, fault - addr,
                                        fault[0], value);
-       print_trailer(s, page, object);
+       print_trailer(s, slab_page(slab), object);
        add_taint(TAINT_BAD_PAGE, LOCKDEP_NOW_UNRELIABLE);
 
 skip_bug_print:
@@ -975,7 +975,7 @@ skip_bug_print:
  * may be used with merged slabcaches.
  */
 
-static int check_pad_bytes(struct kmem_cache *s, struct page *page, u8 *p)
+static int check_pad_bytes(struct kmem_cache *s, struct slab *slab, u8 *p)
 {
        unsigned long off = get_info_end(s);    /* The end of info */
 
@@ -988,7 +988,7 @@ static int check_pad_bytes(struct kmem_cache *s, struct page *page, u8 *p)
        if (size_from_object(s) == off)
                return 1;
 
-       return check_bytes_and_report(s, page, p, "Object padding",
+       return check_bytes_and_report(s, slab, p, "Object padding",
                        p + off, POISON_INUSE, size_from_object(s) - off);
 }
 
@@ -1029,23 +1029,23 @@ static int slab_pad_check(struct kmem_cache *s, struct page *page)
        return 0;
 }
 
-static int check_object(struct kmem_cache *s, struct page *page,
+static int check_object(struct kmem_cache *s, struct slab *slab,
                                        void *object, u8 val)
 {
        u8 *p = object;
        u8 *endobject = object + s->object_size;
 
        if (s->flags & SLAB_RED_ZONE) {
-               if (!check_bytes_and_report(s, page, object, "Left Redzone",
+               if (!check_bytes_and_report(s, slab, object, "Left Redzone",
                        object - s->red_left_pad, val, s->red_left_pad))
                        return 0;
 
-               if (!check_bytes_and_report(s, page, object, "Right Redzone",
+               if (!check_bytes_and_report(s, slab, object, "Right Redzone",
                        endobject, val, s->inuse - s->object_size))
                        return 0;
        } else {
                if ((s->flags & SLAB_POISON) && s->object_size < s->inuse) {
-                       check_bytes_and_report(s, page, p, "Alignment padding",
+                       check_bytes_and_report(s, slab, p, "Alignment padding",
                                endobject, POISON_INUSE,
                                s->inuse - s->object_size);
                }
@@ -1053,15 +1053,15 @@ static int check_object(struct kmem_cache *s, struct page *page,
 
        if (s->flags & SLAB_POISON) {
                if (val != SLUB_RED_ACTIVE && (s->flags & __OBJECT_POISON) &&
-                       (!check_bytes_and_report(s, page, p, "Poison", p,
+                       (!check_bytes_and_report(s, slab, p, "Poison", p,
                                        POISON_FREE, s->object_size - 1) ||
-                        !check_bytes_and_report(s, page, p, "End Poison",
+                        !check_bytes_and_report(s, slab, p, "End Poison",
                                p + s->object_size - 1, POISON_END, 1)))
                        return 0;
                /*
                 * check_pad_bytes cleans up on its own.
                 */
-               check_pad_bytes(s, page, p);
+               check_pad_bytes(s, slab, p);
        }
 
        if (!freeptr_outside_object(s) && val == SLUB_RED_ACTIVE)
@@ -1072,8 +1072,8 @@ static int check_object(struct kmem_cache *s, struct page *page,
                return 1;
 
        /* Check free pointer validity */
-       if (!check_valid_pointer(s, page, get_freepointer(s, p))) {
-               object_err(s, page, p, "Freepointer corrupt");
+       if (!check_valid_pointer(s, slab_page(slab), get_freepointer(s, p))) {
+               object_err(s, slab_page(slab), p, "Freepointer corrupt");
                /*
                 * No choice but to zap it and thus lose the remainder
                 * of the free objects in this slab. May cause
@@ -1271,7 +1271,7 @@ static inline int alloc_consistency_checks(struct kmem_cache *s,
                return 0;
        }
 
-       if (!check_object(s, slab_page(slab), object, SLUB_RED_INACTIVE))
+       if (!check_object(s, slab, object, SLUB_RED_INACTIVE))
                return 0;
 
        return 1;
@@ -1320,7 +1320,7 @@ static inline int free_consistency_checks(struct kmem_cache *s,
                return 0;
        }
 
-       if (!check_object(s, slab_page(slab), object, SLUB_RED_ACTIVE))
+       if (!check_object(s, slab, object, SLUB_RED_ACTIVE))
                return 0;
 
        if (unlikely(s != slab->slab_cache)) {
@@ -1613,7 +1613,7 @@ static inline int free_debug_processing(
 
 static inline int slab_pad_check(struct kmem_cache *s, struct page *page)
                        { return 1; }
-static inline int check_object(struct kmem_cache *s, struct page *page,
+static inline int check_object(struct kmem_cache *s, struct slab *slab,
                        void *object, u8 val) { return 1; }
 static inline void add_full(struct kmem_cache *s, struct kmem_cache_node *n,
                                        struct slab *slab) {}
@@ -1971,7 +1971,7 @@ static void __free_slab(struct kmem_cache *s, struct slab *slab)
 
                slab_pad_check(s, slab_page(slab));
                for_each_object(p, s, slab_address(slab), slab->objects)
-                       check_object(s, slab_page(slab), p, SLUB_RED_INACTIVE);
+                       check_object(s, slab, p, SLUB_RED_INACTIVE);
        }
 
        __slab_clear_pfmemalloc(slab);
@@ -4968,7 +4968,7 @@ static void validate_slab(struct kmem_cache *s, struct slab *slab,
                u8 val = test_bit(__obj_to_index(s, addr, p), obj_map) ?
                         SLUB_RED_INACTIVE : SLUB_RED_ACTIVE;
 
-               if (!check_object(s, slab_page(slab), p, val))
+               if (!check_object(s, slab, p, val))
                        break;
        }
 unlock: