[PATCH] introduce and use kzalloc
authorPekka J Enberg <penberg@cs.Helsinki.FI>
Tue, 6 Sep 2005 22:18:31 +0000 (15:18 -0700)
committerLinus Torvalds <torvalds@g5.osdl.org>
Wed, 7 Sep 2005 23:57:45 +0000 (16:57 -0700)
This patch introduces a kzalloc wrapper and converts kernel/ to use it.  It
saves a little program text.

Signed-off-by: Pekka Enberg <penberg@cs.helsinki.fi>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
include/linux/slab.h
kernel/intermodule.c
kernel/params.c
kernel/power/pm.c
kernel/resource.c
kernel/workqueue.c
mm/slab.c

index 80b2dfde2e8087d84ec06f945f3fa4a61ece4f55..42a6bea58af369f4408eba0cf020dbc6d74352eb 100644 (file)
@@ -99,7 +99,21 @@ found:
        return __kmalloc(size, flags);
 }
 
-extern void *kcalloc(size_t, size_t, unsigned int __nocast);
+extern void *kzalloc(size_t, unsigned int __nocast);
+
+/**
+ * kcalloc - allocate memory for an array. The memory is set to zero.
+ * @n: number of elements.
+ * @size: element size.
+ * @flags: the type of memory to allocate.
+ */
+static inline void *kcalloc(size_t n, size_t size, unsigned int __nocast flags)
+{
+       if (n != 0 && size > INT_MAX / n)
+               return NULL;
+       return kzalloc(n * size, flags);
+}
+
 extern void kfree(const void *);
 extern unsigned int ksize(const void *);
 
index 388977f3e9b7d7a826e57d60a3227da0d4f3c1ac..0cbe633420fb9b6d46376debb0c68d201a5966d5 100644 (file)
@@ -39,7 +39,7 @@ void inter_module_register(const char *im_name, struct module *owner, const void
        struct list_head *tmp;
        struct inter_module_entry *ime, *ime_new;
 
-       if (!(ime_new = kmalloc(sizeof(*ime), GFP_KERNEL))) {
+       if (!(ime_new = kzalloc(sizeof(*ime), GFP_KERNEL))) {
                /* Overloaded kernel, not fatal */
                printk(KERN_ERR
                        "Aiee, inter_module_register: cannot kmalloc entry for '%s'\n",
@@ -47,7 +47,6 @@ void inter_module_register(const char *im_name, struct module *owner, const void
                kmalloc_failed = 1;
                return;
        }
-       memset(ime_new, 0, sizeof(*ime_new));
        ime_new->im_name = im_name;
        ime_new->owner = owner;
        ime_new->userdata = userdata;
index d586c35ef8fca8f4540031c5ad071b90c1071df4..fbf173215fd217bed3db643ba0676916f7085daf 100644 (file)
@@ -542,8 +542,8 @@ static void __init kernel_param_sysfs_setup(const char *name,
 {
        struct module_kobject *mk;
 
-       mk = kmalloc(sizeof(struct module_kobject), GFP_KERNEL);
-       memset(mk, 0, sizeof(struct module_kobject));
+       mk = kzalloc(sizeof(struct module_kobject), GFP_KERNEL);
+       BUG_ON(!mk);
 
        mk->mod = THIS_MODULE;
        kobj_set_kset_s(mk, module_subsys);
index 61deda04e39e2af3d7c31298665e02213afdafdd..159149321b3c2adb4dcf20372ada8edb2a098c7a 100644 (file)
@@ -60,9 +60,8 @@ struct pm_dev *pm_register(pm_dev_t type,
                           unsigned long id,
                           pm_callback callback)
 {
-       struct pm_dev *dev = kmalloc(sizeof(struct pm_dev), GFP_KERNEL);
+       struct pm_dev *dev = kzalloc(sizeof(struct pm_dev), GFP_KERNEL);
        if (dev) {
-               memset(dev, 0, sizeof(*dev));
                dev->type = type;
                dev->id = id;
                dev->callback = callback;
index 26967e0422014a5957f4b01bbed9a4cea40098bf..92285d822de6c9ce3a75825b7b876b8379d522d6 100644 (file)
@@ -430,10 +430,9 @@ EXPORT_SYMBOL(adjust_resource);
  */
 struct resource * __request_region(struct resource *parent, unsigned long start, unsigned long n, const char *name)
 {
-       struct resource *res = kmalloc(sizeof(*res), GFP_KERNEL);
+       struct resource *res = kzalloc(sizeof(*res), GFP_KERNEL);
 
        if (res) {
-               memset(res, 0, sizeof(*res));
                res->name = name;
                res->start = start;
                res->end = start + n - 1;
index a3de837a8dddf7fc0f10daf53b5d1d5fe90928e8..91bacb13a7e2fec56f5067f12e0b97c1043c30b7 100644 (file)
@@ -308,10 +308,9 @@ struct workqueue_struct *__create_workqueue(const char *name,
        struct workqueue_struct *wq;
        struct task_struct *p;
 
-       wq = kmalloc(sizeof(*wq), GFP_KERNEL);
+       wq = kzalloc(sizeof(*wq), GFP_KERNEL);
        if (!wq)
                return NULL;
-       memset(wq, 0, sizeof(*wq));
 
        wq->name = name;
        /* We don't need the distraction of CPUs appearing and vanishing. */
index a9ff4f7f9860b2f1f37891fe4fe8c50a5caa637d..d7c4443991fe8e29e16dfaffa30a1711c6844c30 100644 (file)
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -2558,24 +2558,18 @@ void kmem_cache_free(kmem_cache_t *cachep, void *objp)
 EXPORT_SYMBOL(kmem_cache_free);
 
 /**
- * kcalloc - allocate memory for an array. The memory is set to zero.
- * @n: number of elements.
- * @size: element size.
+ * kzalloc - allocate memory. The memory is set to zero.
+ * @size: how many bytes of memory are required.
  * @flags: the type of memory to allocate.
  */
-void *kcalloc(size_t n, size_t size, unsigned int __nocast flags)
+void *kzalloc(size_t size, unsigned int __nocast flags)
 {
-       void *ret = NULL;
-
-       if (n != 0 && size > INT_MAX / n)
-               return ret;
-
-       ret = kmalloc(n * size, flags);
+       void *ret = kmalloc(size, flags);
        if (ret)
-               memset(ret, 0, n * size);
+               memset(ret, 0, size);
        return ret;
 }
-EXPORT_SYMBOL(kcalloc);
+EXPORT_SYMBOL(kzalloc);
 
 /**
  * kfree - free previously allocated memory