*/
 struct dm_bio_prison *dm_bio_prison_create(void)
 {
-       struct dm_bio_prison *prison = kmalloc(sizeof(*prison), GFP_KERNEL);
+       struct dm_bio_prison *prison = kzalloc(sizeof(*prison), GFP_KERNEL);
        int ret;
 
        if (!prison)
 
  */
 struct dm_bio_prison_v2 *dm_bio_prison_create_v2(struct workqueue_struct *wq)
 {
-       struct dm_bio_prison_v2 *prison = kmalloc(sizeof(*prison), GFP_KERNEL);
+       struct dm_bio_prison_v2 *prison = kzalloc(sizeof(*prison), GFP_KERNEL);
        int ret;
 
        if (!prison)
 
        unsigned min_ios = dm_get_reserved_bio_based_ios();
        int ret;
 
-       client = kmalloc(sizeof(*client), GFP_KERNEL);
+       client = kzalloc(sizeof(*client), GFP_KERNEL);
        if (!client)
                return ERR_PTR(-ENOMEM);
 
 
        int r;
        struct dm_kcopyd_client *kc;
 
-       kc = kmalloc(sizeof(*kc), GFP_KERNEL);
+       kc = kzalloc(sizeof(*kc), GFP_KERNEL);
        if (!kc)
                return ERR_PTR(-ENOMEM);
 
 
                ;
        nr_buckets >>= 1;
 
-       rh = kmalloc(sizeof(*rh), GFP_KERNEL);
+       rh = kzalloc(sizeof(*rh), GFP_KERNEL);
        if (!rh) {
                DMERR("unable to allocate region hash memory");
                return ERR_PTR(-ENOMEM);
 
                origin_mode = FMODE_WRITE;
        }
 
-       s = kmalloc(sizeof(*s), GFP_KERNEL);
+       s = kzalloc(sizeof(*s), GFP_KERNEL);
        if (!s) {
                ti->error = "Cannot allocate private snapshot structure";
                r = -ENOMEM;
 
                return (struct pool *)pmd;
        }
 
-       pool = kmalloc(sizeof(*pool), GFP_KERNEL);
+       pool = kzalloc(sizeof(*pool), GFP_KERNEL);
        if (!pool) {
                *error = "Error allocating memory for pool";
                err_p = ERR_PTR(-ENOMEM);