]> nv-tegra.nvidia Code Review - linux-2.6.git/commitdiff
Merge branches 'topic/fixes', 'topic/cleanups' and 'topic/documentation' into for...
authorPekka Enberg <penberg@cs.helsinki.fi>
Mon, 29 Dec 2008 09:45:47 +0000 (11:45 +0200)
committerPekka Enberg <penberg@cs.helsinki.fi>
Mon, 29 Dec 2008 09:45:47 +0000 (11:45 +0200)
1  2  3 
include/linux/slab.h
mm/slab.c
mm/slub.c

diff --combined include/linux/slab.h
index 9d8ca14be3c435c09d60633075b32ae2cd6c190f,c97ed28559ec3a0ea437900a9b96722ac7597c0d,000da12b5cf03650ad90db9be142d803930fb62e..f96d13c281e81d03bf0b791ccb10b1a918e12055
@@@@ -253,9 -253,9 -253,9 +253,9 @@@@ static inline void *kmem_cache_alloc_no
    * request comes from.
    */
   #if defined(CONFIG_DEBUG_SLAB) || defined(CONFIG_SLUB)
- -extern void *__kmalloc_track_caller(size_t, gfp_t, void*);
+ +extern void *__kmalloc_track_caller(size_t, gfp_t, unsigned long);
   #define kmalloc_track_caller(size, flags) \
- -     __kmalloc_track_caller(size, flags, __builtin_return_address(0))
+ +     __kmalloc_track_caller(size, flags, _RET_IP_)
   #else
   #define kmalloc_track_caller(size, flags) \
        __kmalloc(size, flags)
    * allocation request comes from.
    */
   #if defined(CONFIG_DEBUG_SLAB) || defined(CONFIG_SLUB)
- -extern void *__kmalloc_node_track_caller(size_t, gfp_t, int, void *);
+ +extern void *__kmalloc_node_track_caller(size_t, gfp_t, int, unsigned long);
   #define kmalloc_node_track_caller(size, flags, node) \
        __kmalloc_node_track_caller(size, flags, node, \
- -                     __builtin_return_address(0))
+ +                     _RET_IP_)
   #else
   #define kmalloc_node_track_caller(size, flags, node) \
        __kmalloc_node(size, flags, node)
   #define kmalloc_node_track_caller(size, flags, node) \
        kmalloc_track_caller(size, flags)
   
 --#endif /* DEBUG_SLAB */
 ++#endif /* CONFIG_NUMA */
   
   /*
    * Shortcuts
diff --combined mm/slab.c
index d4b87690b27589ccac812e4b1aeb620f3082e9f0,445bcc87b34697886138c62b9e5e1bd3750cb5b1,c366e3910e89b6a2e150c6b4107d978d9b829364..cb2e411d93a94cf43b07bdc4ee7e1308735ae16c
+++ b/mm/slab.c
@@@@ -2123,6 -2123,6 -2123,8 +2123,8 @@@@ static int __init_refok setup_cpu_cache
    *
    * @name must be valid until the cache is destroyed. This implies that
    * the module calling this has to destroy the cache before getting unloaded.
++  * Note that kmem_cache_name() is not guaranteed to return the same pointer,
++  * therefore applications must manage it themselves.
    *
    * The flags are
    *
@@@@ -2609,7 -2609,7 -2611,7 +2611,7 @@@@ static struct slab *alloc_slabmgmt(stru
        if (OFF_SLAB(cachep)) {
                /* Slab management obj is off-slab. */
                slabp = kmem_cache_alloc_node(cachep->slabp_cache,
 --                                           local_flags & ~GFP_THISNODE, nodeid);
 ++                                           local_flags, nodeid);
                if (!slabp)
                        return NULL;
        } else {
@@@@ -2997,7 -2997,7 -2999,7 +2999,7 @@@@ retry
                 * there must be at least one object available for
                 * allocation.
                 */
- -             BUG_ON(slabp->inuse < 0 || slabp->inuse >= cachep->num);
+ +             BUG_ON(slabp->inuse >= cachep->num);
   
                while (slabp->inuse < cachep->num && batchcount--) {
                        STATS_INC_ALLOCED(cachep);
@@@@ -3686,9 -3686,9 -3688,9 +3688,9 @@@@ void *__kmalloc_node(size_t size, gfp_
   EXPORT_SYMBOL(__kmalloc_node);
   
   void *__kmalloc_node_track_caller(size_t size, gfp_t flags,
- -             int node, void *caller)
+ +             int node, unsigned long caller)
   {
- -     return __do_kmalloc_node(size, flags, node, caller);
+ +     return __do_kmalloc_node(size, flags, node, (void *)caller);
   }
   EXPORT_SYMBOL(__kmalloc_node_track_caller);
   #else
@@@@ -3730,9 -3730,9 -3732,9 +3732,9 @@@@ void *__kmalloc(size_t size, gfp_t flag
   }
   EXPORT_SYMBOL(__kmalloc);
   
- -void *__kmalloc_track_caller(size_t size, gfp_t flags, void *caller)
+ +void *__kmalloc_track_caller(size_t size, gfp_t flags, unsigned long caller)
   {
- -     return __do_kmalloc(size, flags, caller);
+ +     return __do_kmalloc(size, flags, (void *)caller);
   }
   EXPORT_SYMBOL(__kmalloc_track_caller);
   
diff --combined mm/slub.c
index d057ceb3645f5bf318070e2d162fba242bc69063,5c8dbe3ae509a6b8defc9a4d157355ab4363aabd,7ad489af95614602a2f5fec8756460108a1f6be1..ca95e45f04c3e41473001303df7c2f596ccba47d
+++ b/mm/slub.c
   #define ARCH_SLAB_MINALIGN __alignof__(unsigned long long)
   #endif
   
+ +#define OO_SHIFT     16
+ +#define OO_MASK              ((1 << OO_SHIFT) - 1)
+ +#define MAX_OBJS_PER_PAGE    65535 /* since page.objects is u16 */
+ +
   /* Internal SLUB flags */
   #define __OBJECT_POISON              0x80000000 /* Poison object */
   #define __SYSFS_ADD_DEFERRED 0x40000000 /* Not yet visible via sysfs */
@@@@ -178,7 -182,7 -178,7 +182,7 @@@@ static LIST_HEAD(slab_caches)
    * Tracking user of a slab.
    */
   struct track {
- -     void *addr;             /* Called from address */
+ +     unsigned long addr;     /* Called from address */
        int cpu;                /* Was running on cpu */
        int pid;                /* Pid context */
        unsigned long when;     /* When did the operation occur */
@@@@ -290,7 -294,7 -290,7 +294,7 @@@@ static inline struct kmem_cache_order_o
                                                unsigned long size)
   {
        struct kmem_cache_order_objects x = {
- -             (order << 16) + (PAGE_SIZE << order) / size
+ +             (order << OO_SHIFT) + (PAGE_SIZE << order) / size
        };
   
        return x;
   
   static inline int oo_order(struct kmem_cache_order_objects x)
   {
- -     return x.x >> 16;
+ +     return x.x >> OO_SHIFT;
   }
   
   static inline int oo_objects(struct kmem_cache_order_objects x)
   {
- -     return x.x & ((1 << 16) - 1);
+ +     return x.x & OO_MASK;
   }
   
   #ifdef CONFIG_SLUB_DEBUG
@@@@ -367,7 -371,7 -367,7 +371,7 @@@@ static struct track *get_track(struct k
   }
   
   static void set_track(struct kmem_cache *s, void *object,
- -                             enum track_item alloc, void *addr)
+ +                     enum track_item alloc, unsigned long addr)
   {
        struct track *p;
   
@@@@ -391,8 -395,8 -391,8 +395,8 @@@@ static void init_tracking(struct kmem_c
        if (!(s->flags & SLAB_STORE_USER))
                return;
   
- -     set_track(s, object, TRACK_FREE, NULL);
- -     set_track(s, object, TRACK_ALLOC, NULL);
+ +     set_track(s, object, TRACK_FREE, 0UL);
+ +     set_track(s, object, TRACK_ALLOC, 0UL);
   }
   
   static void print_track(const char *s, struct track *t)
                return;
   
        printk(KERN_ERR "INFO: %s in %pS age=%lu cpu=%u pid=%d\n",
- -             s, t->addr, jiffies - t->when, t->cpu, t->pid);
+ +             s, (void *)t->addr, jiffies - t->when, t->cpu, t->pid);
   }
   
   static void print_tracking(struct kmem_cache *s, void *object)
@@@@ -692,7 -696,7 -692,7 +696,7 @@@@ static int check_object(struct kmem_cac
        if (!check_valid_pointer(s, page, get_freepointer(s, p))) {
                object_err(s, page, p, "Freepointer corrupt");
                /*
- -              * No choice but to zap it and thus loose the remainder
+ +              * No choice but to zap it and thus lose the remainder
                 * of the free objects in this slab. May cause
                 * another error because the object count is now wrong.
                 */
@@@@ -764,8 -768,8 -764,8 +768,8 @@@@ static int on_freelist(struct kmem_cach
        }
   
        max_objects = (PAGE_SIZE << compound_order(page)) / s->size;
- -     if (max_objects > 65535)
- -             max_objects = 65535;
+ +     if (max_objects > MAX_OBJS_PER_PAGE)
+ +             max_objects = MAX_OBJS_PER_PAGE;
   
        if (page->objects != max_objects) {
                slab_err(s, page, "Wrong number of objects. Found %d but "
@@@@ -866,7 -870,7 -866,7 +870,7 @@@@ static void setup_object_debug(struct k
   }
   
   static int alloc_debug_processing(struct kmem_cache *s, struct page *page,
- -                                             void *object, void *addr)
+ +                                     void *object, unsigned long addr)
   {
        if (!check_slab(s, page))
                goto bad;
@@@@ -906,7 -910,7 -906,7 +910,7 @@@@ bad
   }
   
   static int free_debug_processing(struct kmem_cache *s, struct page *page,
- -                                             void *object, void *addr)
+ +                                     void *object, unsigned long addr)
   {
        if (!check_slab(s, page))
                goto fail;
@@@@ -1029,10 -1033,10 -1029,10 +1033,10 @@@@ static inline void setup_object_debug(s
                        struct page *page, void *object) {}
   
   static inline int alloc_debug_processing(struct kmem_cache *s,
- -     struct page *page, void *object, void *addr) { return 0; }
+ +     struct page *page, void *object, unsigned long addr) { return 0; }
   
   static inline int free_debug_processing(struct kmem_cache *s,
- -     struct page *page, void *object, void *addr) { return 0; }
+ +     struct page *page, void *object, unsigned long addr) { return 0; }
   
   static inline int slab_pad_check(struct kmem_cache *s, struct page *page)
                        { return 1; }
@@@@ -1499,8 -1503,8 -1499,8 +1503,8 @@@@ static inline int node_match(struct kme
    * we need to allocate a new slab. This is the slowest path since it involves
    * a call to the page allocator and the setup of a new slab.
    */
- -static void *__slab_alloc(struct kmem_cache *s,
- -             gfp_t gfpflags, int node, void *addr, struct kmem_cache_cpu *c)
+ +static void *__slab_alloc(struct kmem_cache *s, gfp_t gfpflags, int node,
+ +                       unsigned long addr, struct kmem_cache_cpu *c)
   {
        void **object;
        struct page *new;
    * Otherwise we can simply pick the next object from the lockless free list.
    */
   static __always_inline void *slab_alloc(struct kmem_cache *s,
- -             gfp_t gfpflags, int node, void *addr)
+ +             gfp_t gfpflags, int node, unsigned long addr)
   {
        void **object;
        struct kmem_cache_cpu *c;
        unsigned long flags;
        unsigned int objsize;
   
 ++     might_sleep_if(gfpflags & __GFP_WAIT);
        local_irq_save(flags);
        c = get_cpu_slab(s, smp_processor_id());
        objsize = c->objsize;
   
   void *kmem_cache_alloc(struct kmem_cache *s, gfp_t gfpflags)
   {
- -     return slab_alloc(s, gfpflags, -1, __builtin_return_address(0));
+ +     return slab_alloc(s, gfpflags, -1, _RET_IP_);
   }
   EXPORT_SYMBOL(kmem_cache_alloc);
   
   #ifdef CONFIG_NUMA
   void *kmem_cache_alloc_node(struct kmem_cache *s, gfp_t gfpflags, int node)
   {
- -     return slab_alloc(s, gfpflags, node, __builtin_return_address(0));
+ +     return slab_alloc(s, gfpflags, node, _RET_IP_);
   }
   EXPORT_SYMBOL(kmem_cache_alloc_node);
   #endif
    * handling required then we can return immediately.
    */
   static void __slab_free(struct kmem_cache *s, struct page *page,
- -                             void *x, void *addr, unsigned int offset)
+ +                     void *x, unsigned long addr, unsigned int offset)
   {
        void *prior;
        void **object = (void *)x;
@@@@ -1705,7 -1708,7 -1704,7 +1709,7 @@@@ debug
    * with all sorts of special processing.
    */
   static __always_inline void slab_free(struct kmem_cache *s,
- -                     struct page *page, void *x, void *addr)
+ +                     struct page *page, void *x, unsigned long addr)
   {
        void **object = (void *)x;
        struct kmem_cache_cpu *c;
@@@@ -1732,11 -1735,11 -1731,11 +1736,11 @@@@ void kmem_cache_free(struct kmem_cache 
   
        page = virt_to_head_page(x);
   
- -     slab_free(s, page, x, __builtin_return_address(0));
+ +     slab_free(s, page, x, _RET_IP_);
   }
   EXPORT_SYMBOL(kmem_cache_free);
   
- -/* Figure out on which slab object the object resides */
+ +/* Figure out on which slab page the object resides */
   static struct page *get_object_page(const void *x)
   {
        struct page *page = virt_to_head_page(x);
@@@@ -1808,8 -1811,8 -1807,8 +1812,8 @@@@ static inline int slab_order(int size, 
        int rem;
        int min_order = slub_min_order;
   
- -     if ((PAGE_SIZE << min_order) / size > 65535)
- -             return get_order(size * 65535) - 1;
+ +     if ((PAGE_SIZE << min_order) / size > MAX_OBJS_PER_PAGE)
+ +             return get_order(size * MAX_OBJS_PER_PAGE) - 1;
   
        for (order = max(min_order,
                                fls(min_objects * size - 1) - PAGE_SHIFT);
@@@@ -2074,8 -2077,7 -2073,8 +2078,7 @@@@ static inline int alloc_kmem_cache_cpus
    * when allocating for the kmalloc_node_cache. This is used for bootstrapping
    * memory on a fresh node that has no slab structures yet.
    */
- -static struct kmem_cache_node *early_kmem_cache_node_alloc(gfp_t gfpflags,
- -                                                        int node)
+ +static void early_kmem_cache_node_alloc(gfp_t gfpflags, int node)
   {
        struct page *page;
        struct kmem_cache_node *n;
        local_irq_save(flags);
        add_partial(n, page, 0);
        local_irq_restore(flags);
- -     return n;
   }
   
   static void free_kmem_cache_nodes(struct kmem_cache *s)
@@@@ -2145,8 -2146,7 -2144,8 +2147,7 @@@@ static int init_kmem_cache_nodes(struc
                        n = &s->local_node;
                else {
                        if (slab_state == DOWN) {
- -                             n = early_kmem_cache_node_alloc(gfpflags,
- -                                                             node);
+ +                             early_kmem_cache_node_alloc(gfpflags, node);
                                continue;
                        }
                        n = kmem_cache_alloc_node(kmalloc_caches,
@@@@ -2660,7 -2660,7 -2659,7 +2661,7 @@@@ void *__kmalloc(size_t size, gfp_t flag
        if (unlikely(ZERO_OR_NULL_PTR(s)))
                return s;
   
- -     return slab_alloc(s, flags, -1, __builtin_return_address(0));
+ +     return slab_alloc(s, flags, -1, _RET_IP_);
   }
   EXPORT_SYMBOL(__kmalloc);
   
@@@@ -2688,7 -2688,7 -2687,7 +2689,7 @@@@ void *__kmalloc_node(size_t size, gfp_
        if (unlikely(ZERO_OR_NULL_PTR(s)))
                return s;
   
- -     return slab_alloc(s, flags, node, __builtin_return_address(0));
+ +     return slab_alloc(s, flags, node, _RET_IP_);
   }
   EXPORT_SYMBOL(__kmalloc_node);
   #endif
@@@@ -2745,7 -2745,7 -2744,7 +2746,7 @@@@ void kfree(const void *x
                put_page(page);
                return;
        }
- -     slab_free(page->slab, page, object, __builtin_return_address(0));
+ +     slab_free(page->slab, page, object, _RET_IP_);
   }
   EXPORT_SYMBOL(kfree);
   
@@@@ -2932,10 -2932,8 -2931,8 +2933,10 @@@@ static int slab_memory_callback(struct 
        case MEM_CANCEL_OFFLINE:
                break;
        }
 --
 --     ret = notifier_from_errno(ret);
 ++     if (ret)
 ++             ret = notifier_from_errno(ret);
 ++     else
 ++             ret = NOTIFY_OK;
        return ret;
   }
   
@@@@ -3124,12 -3122,8 -3121,8 +3125,12 @@@@ struct kmem_cache *kmem_cache_create(co
                s->inuse = max_t(int, s->inuse, ALIGN(size, sizeof(void *)));
                up_write(&slub_lock);
   
 --             if (sysfs_slab_alias(s, name))
 ++             if (sysfs_slab_alias(s, name)) {
 ++                     down_write(&slub_lock);
 ++                     s->refcount--;
 ++                     up_write(&slub_lock);
                        goto err;
 ++             }
                return s;
        }
   
                                size, align, flags, ctor)) {
                        list_add(&s->list, &slab_caches);
                        up_write(&slub_lock);
 --                     if (sysfs_slab_add(s))
 ++                     if (sysfs_slab_add(s)) {
 ++                             down_write(&slub_lock);
 ++                             list_del(&s->list);
 ++                             up_write(&slub_lock);
 ++                             kfree(s);
                                goto err;
 ++                     }
                        return s;
                }
                kfree(s);
@@@@ -3212,7 -3201,7 -3200,7 +3213,7 @@@@ static struct notifier_block __cpuinitd
   
   #endif
   
- -void *__kmalloc_track_caller(size_t size, gfp_t gfpflags, void *caller)
+ +void *__kmalloc_track_caller(size_t size, gfp_t gfpflags, unsigned long caller)
   {
        struct kmem_cache *s;
   
   }
   
   void *__kmalloc_node_track_caller(size_t size, gfp_t gfpflags,
- -                                     int node, void *caller)
+ +                                     int node, unsigned long caller)
   {
        struct kmem_cache *s;
   
@@@@ -3439,7 -3428,7 -3427,7 +3440,7 @@@@ static void resiliency_test(void) {}
   
   struct location {
        unsigned long count;
- -     void *addr;
+ +     unsigned long addr;
        long long sum_time;
        long min_time;
        long max_time;
@@@@ -3487,7 -3476,7 -3475,7 +3488,7 @@@@ static int add_location(struct loc_trac
   {
        long start, end, pos;
        struct location *l;
- -     void *caddr;
+ +     unsigned long caddr;
        unsigned long age = jiffies - track->when;
   
        start = -1;
@@@@ -3607,7 -3596,7 -3595,7 +3608,7 @@@@ static int list_locations(struct kmem_c
        for (i = 0; i < t.count; i++) {
                struct location *l = &t.loc[i];
   
 --             if (len > PAGE_SIZE - 100)
 ++             if (len > PAGE_SIZE - KSYM_SYMBOL_LEN - 100)
                        break;
                len += sprintf(buf + len, "%7ld ", l->count);
   
@@@@ -4355,7 -4344,7 -4343,7 +4356,7 @@@@ static void sysfs_slab_remove(struct km
   
   /*
    * Need to buffer aliases during bootup until sysfs becomes
- - * available lest we loose that information.
+ + * available lest we lose that information.
    */
   struct saved_alias {
        struct kmem_cache *s;