Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 94f6030c authored by Christoph Lameter's avatar Christoph Lameter Committed by Linus Torvalds
Browse files

Slab allocators: Replace explicit zeroing with __GFP_ZERO 



kmalloc_node() and kmem_cache_alloc_node() were not available in a zeroing
variant in the past.  But with __GFP_ZERO it is possible now to do zeroing
while allocating.

Use __GFP_ZERO to remove the explicit clearing of memory via memset whereever
we can.

Signed-off-by: default avatarChristoph Lameter <clameter@sgi.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 81cda662

block/as-iosched.c

+1 −2
Original line number Diff line number Diff line
@@ -1322,10 +1322,9 @@ static void *as_init_queue(request_queue_t *q) 
{

	struct as_data *ad;



	ad = kmalloc_node(sizeof(*ad), GFP_KERNEL, q->node);

	ad = kmalloc_node(sizeof(*ad), GFP_KERNEL | __GFP_ZERO, q->node);

	if (!ad)

		return NULL;

	memset(ad, 0, sizeof(*ad));



	ad->q = q; /* Identify what queue the data belongs to */

block/cfq-iosched.c

+9 −9
Original line number Diff line number Diff line
@@ -1251,9 +1251,9 @@ cfq_alloc_io_context(struct cfq_data *cfqd, gfp_t gfp_mask) 
{

	struct cfq_io_context *cic;



	cic = kmem_cache_alloc_node(cfq_ioc_pool, gfp_mask, cfqd->queue->node);

	cic = kmem_cache_alloc_node(cfq_ioc_pool, gfp_mask | __GFP_ZERO,

							cfqd->queue->node);

	if (cic) {

		memset(cic, 0, sizeof(*cic));

		cic->last_end_request = jiffies;

		INIT_LIST_HEAD(&cic->queue_list);

		cic->dtor = cfq_free_io_context;
@@ -1376,17 +1376,19 @@ cfq_find_alloc_queue(struct cfq_data *cfqd, int is_sync, 
			 * free memory.

			 */

			spin_unlock_irq(cfqd->queue->queue_lock);

			new_cfqq = kmem_cache_alloc_node(cfq_pool, gfp_mask|__GFP_NOFAIL, cfqd->queue->node);

			new_cfqq = kmem_cache_alloc_node(cfq_pool,

					gfp_mask | __GFP_NOFAIL | __GFP_ZERO,

					cfqd->queue->node);

			spin_lock_irq(cfqd->queue->queue_lock);

			goto retry;

		} else {

			cfqq = kmem_cache_alloc_node(cfq_pool, gfp_mask, cfqd->queue->node);

			cfqq = kmem_cache_alloc_node(cfq_pool,

					gfp_mask | __GFP_ZERO,

					cfqd->queue->node);

			if (!cfqq)

				goto out;

		}



		memset(cfqq, 0, sizeof(*cfqq));



		RB_CLEAR_NODE(&cfqq->rb_node);

		INIT_LIST_HEAD(&cfqq->fifo);
@@ -2079,12 +2081,10 @@ static void *cfq_init_queue(request_queue_t *q) 
{

	struct cfq_data *cfqd;



	cfqd = kmalloc_node(sizeof(*cfqd), GFP_KERNEL, q->node);

	cfqd = kmalloc_node(sizeof(*cfqd), GFP_KERNEL | __GFP_ZERO, q->node);

	if (!cfqd)

		return NULL;



	memset(cfqd, 0, sizeof(*cfqd));



	cfqd->service_tree = CFQ_RB_ROOT;

	INIT_LIST_HEAD(&cfqd->cic_list);

block/deadline-iosched.c

+1 −2
Original line number Diff line number Diff line
@@ -360,10 +360,9 @@ static void *deadline_init_queue(request_queue_t *q) 
{

	struct deadline_data *dd;



	dd = kmalloc_node(sizeof(*dd), GFP_KERNEL, q->node);

	dd = kmalloc_node(sizeof(*dd), GFP_KERNEL | __GFP_ZERO, q->node);

	if (!dd)

		return NULL;

	memset(dd, 0, sizeof(*dd));



	INIT_LIST_HEAD(&dd->fifo_list[READ]);

	INIT_LIST_HEAD(&dd->fifo_list[WRITE]);

block/elevator.c

+1 −2
Original line number Diff line number Diff line
@@ -177,11 +177,10 @@ static elevator_t *elevator_alloc(request_queue_t *q, struct elevator_type *e) 
	elevator_t *eq;

	int i;



	eq = kmalloc_node(sizeof(elevator_t), GFP_KERNEL, q->node);

	eq = kmalloc_node(sizeof(elevator_t), GFP_KERNEL | __GFP_ZERO, q->node);

	if (unlikely(!eq))

		goto err;



	memset(eq, 0, sizeof(*eq));

	eq->ops = &e->ops;

	eq->elevator_type = e;

	kobject_init(&eq->kobj);

block/genhd.c

+4 −4
Original line number Diff line number Diff line
@@ -726,21 +726,21 @@ struct gendisk *alloc_disk_node(int minors, int node_id) 
{

	struct gendisk *disk;



	disk = kmalloc_node(sizeof(struct gendisk), GFP_KERNEL, node_id);

	disk = kmalloc_node(sizeof(struct gendisk),

				GFP_KERNEL | __GFP_ZERO, node_id);

	if (disk) {

		memset(disk, 0, sizeof(struct gendisk));

		if (!init_disk_stats(disk)) {

			kfree(disk);

			return NULL;

		}

		if (minors > 1) {

			int size = (minors - 1) * sizeof(struct hd_struct *);

			disk->part = kmalloc_node(size, GFP_KERNEL, node_id);

			disk->part = kmalloc_node(size,

				GFP_KERNEL | __GFP_ZERO, node_id);

			if (!disk->part) {

				kfree(disk);

				return NULL;

			}

			memset(disk->part, 0, size);

		}

		disk->minors = minors;

		kobj_set_kset_s(disk,block_subsys);