Commit fd6b99fa authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'akpm' (patches from Andrew) 

Merge misc fixes from Andrew Morton:
 "16 fixes"

* emailed patches from Andrew Morton <akpm@linux-foundation.org>:
  mm/devm_memremap_pages: fix final page put race
  PCI/P2PDMA: track pgmap references per resource, not globally
  lib/genalloc: introduce chunk owners
  PCI/P2PDMA: fix the gen_pool_add_virt() failure path
  mm/devm_memremap_pages: introduce devm_memunmap_pages
  drivers/base/devres: introduce devm_release_action()
  mm/vmscan.c: fix trying to reclaim unevictable LRU page
  coredump: fix race condition between collapse_huge_page() and core dumping
  mm/mlock.c: change count_mm_mlocked_page_nr return type
  mm: mmu_gather: remove __tlb_reset_range() for force flush
  fs/ocfs2: fix race in ocfs2_dentry_attach_lock()
  mm/vmscan.c: fix recent_rotated history
  mm/mlock.c: mlockall error for flag MCL_ONFAULT
  scripts/decode_stacktrace.sh: prefix addr2line with $CROSS_COMPILE
  mm/list_lru.c: fix memory leak in __memcg_init_list_lru_node
  mm: memcontrol: don't batch updates of local VM stats and events
parents c78ad1be 50f44ee7

drivers/base/devres.c

+23 −1
Original line number Diff line number Diff line
@@ -755,10 +755,32 @@ void devm_remove_action(struct device *dev, void (*action)(void *), void *data) 


	WARN_ON(devres_destroy(dev, devm_action_release, devm_action_match,

			       &devres));



}

EXPORT_SYMBOL_GPL(devm_remove_action);



/**

 * devm_release_action() - release previously added custom action

 * @dev: Device that owns the action

 * @action: Function implementing the action

 * @data: Pointer to data passed to @action implementation

 *

 * Releases and removes instance of @action previously added by

 * devm_add_action().  Both action and data should match one of the

 * existing entries.

 */

void devm_release_action(struct device *dev, void (*action)(void *), void *data)

{

	struct action_devres devres = {

		.data = data,

		.action = action,

	};



	WARN_ON(devres_release(dev, devm_action_release, devm_action_match,

			       &devres));



}

EXPORT_SYMBOL_GPL(devm_release_action);



/*

 * Managed kmalloc/kfree

 */

drivers/dax/device.c

+3 −10
Original line number Diff line number Diff line
@@ -27,9 +27,8 @@ static void dev_dax_percpu_release(struct percpu_ref *ref) 
	complete(&dev_dax->cmp);

}



static void dev_dax_percpu_exit(void *data)

static void dev_dax_percpu_exit(struct percpu_ref *ref)

{

	struct percpu_ref *ref = data;

	struct dev_dax *dev_dax = ref_to_dev_dax(ref);



	dev_dbg(&dev_dax->dev, "%s\n", __func__);
@@ -466,18 +465,12 @@ int dev_dax_probe(struct device *dev) 
	if (rc)

		return rc;



	rc = devm_add_action_or_reset(dev, dev_dax_percpu_exit, &dev_dax->ref);

	if (rc)

		return rc;



	dev_dax->pgmap.ref = &dev_dax->ref;

	dev_dax->pgmap.kill = dev_dax_percpu_kill;

	dev_dax->pgmap.cleanup = dev_dax_percpu_exit;

	addr = devm_memremap_pages(dev, &dev_dax->pgmap);

	if (IS_ERR(addr)) {

		devm_remove_action(dev, dev_dax_percpu_exit, &dev_dax->ref);

		percpu_ref_exit(&dev_dax->ref);

	if (IS_ERR(addr))

		return PTR_ERR(addr);

	}



	inode = dax_inode(dax_dev);

	cdev = inode->i_cdev;

drivers/nvdimm/pmem.c

+13 −4
Original line number Diff line number Diff line
@@ -303,11 +303,19 @@ static const struct attribute_group *pmem_attribute_groups[] = { 
	NULL,

};



static void pmem_release_queue(void *q)

static void __pmem_release_queue(struct percpu_ref *ref)

{

	struct request_queue *q;



	q = container_of(ref, typeof(*q), q_usage_counter);

	blk_cleanup_queue(q);

}



static void pmem_release_queue(void *ref)

{

	__pmem_release_queue(ref);

}



static void pmem_freeze_queue(struct percpu_ref *ref)

{

	struct request_queue *q;
@@ -399,12 +407,10 @@ static int pmem_attach_disk(struct device *dev, 
	if (!q)

		return -ENOMEM;



	if (devm_add_action_or_reset(dev, pmem_release_queue, q))

		return -ENOMEM;



	pmem->pfn_flags = PFN_DEV;

	pmem->pgmap.ref = &q->q_usage_counter;

	pmem->pgmap.kill = pmem_freeze_queue;

	pmem->pgmap.cleanup = __pmem_release_queue;

	if (is_nd_pfn(dev)) {

		if (setup_pagemap_fsdax(dev, &pmem->pgmap))

			return -ENOMEM;
@@ -425,6 +431,9 @@ static int pmem_attach_disk(struct device *dev, 
		pmem->pfn_flags |= PFN_MAP;

		memcpy(&bb_res, &pmem->pgmap.res, sizeof(bb_res));

	} else {

		if (devm_add_action_or_reset(dev, pmem_release_queue,

					&q->q_usage_counter))

			return -ENOMEM;

		addr = devm_memremap(dev, pmem->phys_addr,

				pmem->size, ARCH_MEMREMAP_PMEM);

		memcpy(&bb_res, &nsio->res, sizeof(bb_res));

drivers/pci/p2pdma.c

+72 −43
Original line number Diff line number Diff line
@@ -20,12 +20,16 @@ 
#include <linux/seq_buf.h>



struct pci_p2pdma {

	struct percpu_ref devmap_ref;

	struct completion devmap_ref_done;

	struct gen_pool *pool;

	bool p2pmem_published;

};



struct p2pdma_pagemap {

	struct dev_pagemap pgmap;

	struct percpu_ref ref;

	struct completion ref_done;

};



static ssize_t size_show(struct device *dev, struct device_attribute *attr,

			 char *buf)

{
@@ -74,41 +78,45 @@ static const struct attribute_group p2pmem_group = { 
	.name = "p2pmem",

};



static struct p2pdma_pagemap *to_p2p_pgmap(struct percpu_ref *ref)

{

	return container_of(ref, struct p2pdma_pagemap, ref);

}



static void pci_p2pdma_percpu_release(struct percpu_ref *ref)

{

	struct pci_p2pdma *p2p =

		container_of(ref, struct pci_p2pdma, devmap_ref);

	struct p2pdma_pagemap *p2p_pgmap = to_p2p_pgmap(ref);



	complete_all(&p2p->devmap_ref_done);

	complete(&p2p_pgmap->ref_done);

}



static void pci_p2pdma_percpu_kill(struct percpu_ref *ref)

{

	/*

	 * pci_p2pdma_add_resource() may be called multiple times

	 * by a driver and may register the percpu_kill devm action multiple

	 * times. We only want the first action to actually kill the

	 * percpu_ref.

	 */

	if (percpu_ref_is_dying(ref))

		return;



	percpu_ref_kill(ref);

}



static void pci_p2pdma_percpu_cleanup(struct percpu_ref *ref)

{

	struct p2pdma_pagemap *p2p_pgmap = to_p2p_pgmap(ref);



	wait_for_completion(&p2p_pgmap->ref_done);

	percpu_ref_exit(&p2p_pgmap->ref);

}



static void pci_p2pdma_release(void *data)

{

	struct pci_dev *pdev = data;

	struct pci_p2pdma *p2pdma = pdev->p2pdma;



	if (!pdev->p2pdma)

	if (!p2pdma)

		return;



	wait_for_completion(&pdev->p2pdma->devmap_ref_done);

	percpu_ref_exit(&pdev->p2pdma->devmap_ref);

	/* Flush and disable pci_alloc_p2p_mem() */

	pdev->p2pdma = NULL;

	synchronize_rcu();



	gen_pool_destroy(pdev->p2pdma->pool);

	gen_pool_destroy(p2pdma->pool);

	sysfs_remove_group(&pdev->dev.kobj, &p2pmem_group);

	pdev->p2pdma = NULL;

}



static int pci_p2pdma_setup(struct pci_dev *pdev)
@@ -124,12 +132,6 @@ static int pci_p2pdma_setup(struct pci_dev *pdev) 
	if (!p2p->pool)

		goto out;



	init_completion(&p2p->devmap_ref_done);

	error = percpu_ref_init(&p2p->devmap_ref,

			pci_p2pdma_percpu_release, 0, GFP_KERNEL);

	if (error)

		goto out_pool_destroy;



	error = devm_add_action_or_reset(&pdev->dev, pci_p2pdma_release, pdev);

	if (error)

		goto out_pool_destroy;
@@ -163,6 +165,7 @@ out: 
int pci_p2pdma_add_resource(struct pci_dev *pdev, int bar, size_t size,

			    u64 offset)

{

	struct p2pdma_pagemap *p2p_pgmap;

	struct dev_pagemap *pgmap;

	void *addr;

	int error;
@@ -185,18 +188,27 @@ int pci_p2pdma_add_resource(struct pci_dev *pdev, int bar, size_t size, 
			return error;

	}



	pgmap = devm_kzalloc(&pdev->dev, sizeof(*pgmap), GFP_KERNEL);

	if (!pgmap)

	p2p_pgmap = devm_kzalloc(&pdev->dev, sizeof(*p2p_pgmap), GFP_KERNEL);

	if (!p2p_pgmap)

		return -ENOMEM;



	init_completion(&p2p_pgmap->ref_done);

	error = percpu_ref_init(&p2p_pgmap->ref,

			pci_p2pdma_percpu_release, 0, GFP_KERNEL);

	if (error)

		goto pgmap_free;



	pgmap = &p2p_pgmap->pgmap;



	pgmap->res.start = pci_resource_start(pdev, bar) + offset;

	pgmap->res.end = pgmap->res.start + size - 1;

	pgmap->res.flags = pci_resource_flags(pdev, bar);

	pgmap->ref = &pdev->p2pdma->devmap_ref;

	pgmap->ref = &p2p_pgmap->ref;

	pgmap->type = MEMORY_DEVICE_PCI_P2PDMA;

	pgmap->pci_p2pdma_bus_offset = pci_bus_address(pdev, bar) -

		pci_resource_start(pdev, bar);

	pgmap->kill = pci_p2pdma_percpu_kill;

	pgmap->cleanup = pci_p2pdma_percpu_cleanup;



	addr = devm_memremap_pages(&pdev->dev, pgmap);

	if (IS_ERR(addr)) {
@@ -204,19 +216,22 @@ int pci_p2pdma_add_resource(struct pci_dev *pdev, int bar, size_t size, 
		goto pgmap_free;

	}



	error = gen_pool_add_virt(pdev->p2pdma->pool, (unsigned long)addr,

	error = gen_pool_add_owner(pdev->p2pdma->pool, (unsigned long)addr,

			pci_bus_address(pdev, bar) + offset,

			resource_size(&pgmap->res), dev_to_node(&pdev->dev));

			resource_size(&pgmap->res), dev_to_node(&pdev->dev),

			&p2p_pgmap->ref);

	if (error)

		goto pgmap_free;

		goto pages_free;



	pci_info(pdev, "added peer-to-peer DMA memory %pR\n",

		 &pgmap->res);



	return 0;



pages_free:

	devm_memunmap_pages(&pdev->dev, pgmap);

pgmap_free:

	devm_kfree(&pdev->dev, pgmap);

	devm_kfree(&pdev->dev, p2p_pgmap);

	return error;

}

EXPORT_SYMBOL_GPL(pci_p2pdma_add_resource);
@@ -585,19 +600,30 @@ EXPORT_SYMBOL_GPL(pci_p2pmem_find_many); 
 */

void *pci_alloc_p2pmem(struct pci_dev *pdev, size_t size)

{

	void *ret;

	void *ret = NULL;

	struct percpu_ref *ref;



	/*

	 * Pairs with synchronize_rcu() in pci_p2pdma_release() to

	 * ensure pdev->p2pdma is non-NULL for the duration of the

	 * read-lock.

	 */

	rcu_read_lock();

	if (unlikely(!pdev->p2pdma))

		return NULL;



	if (unlikely(!percpu_ref_tryget_live(&pdev->p2pdma->devmap_ref)))

		return NULL;



	ret = (void *)gen_pool_alloc(pdev->p2pdma->pool, size);

		goto out;



	if (unlikely(!ret))

		percpu_ref_put(&pdev->p2pdma->devmap_ref);

	ret = (void *)gen_pool_alloc_owner(pdev->p2pdma->pool, size,

			(void **) &ref);

	if (!ret)

		goto out;



	if (unlikely(!percpu_ref_tryget_live(ref))) {

		gen_pool_free(pdev->p2pdma->pool, (unsigned long) ret, size);

		ret = NULL;

		goto out;

	}

out:

	rcu_read_unlock();

	return ret;

}

EXPORT_SYMBOL_GPL(pci_alloc_p2pmem);
@@ -610,8 +636,11 @@ EXPORT_SYMBOL_GPL(pci_alloc_p2pmem); 
 */

void pci_free_p2pmem(struct pci_dev *pdev, void *addr, size_t size)

{

	gen_pool_free(pdev->p2pdma->pool, (uintptr_t)addr, size);

	percpu_ref_put(&pdev->p2pdma->devmap_ref);

	struct percpu_ref *ref;



	gen_pool_free_owner(pdev->p2pdma->pool, (uintptr_t)addr, size,

			(void **) &ref);

	percpu_ref_put(ref);

}

EXPORT_SYMBOL_GPL(pci_free_p2pmem);

fs/ocfs2/dcache.c

+12 −0
Original line number Diff line number Diff line
@@ -296,6 +296,18 @@ int ocfs2_dentry_attach_lock(struct dentry *dentry, 


out_attach:

	spin_lock(&dentry_attach_lock);

	if (unlikely(dentry->d_fsdata && !alias)) {

		/* d_fsdata is set by a racing thread which is doing

		 * the same thing as this thread is doing. Leave the racing

		 * thread going ahead and we return here.

		 */

		spin_unlock(&dentry_attach_lock);

		iput(dl->dl_inode);

		ocfs2_lock_res_free(&dl->dl_lockres);

		kfree(dl);

		return 0;

	}



	dentry->d_fsdata = dl;

	dl->dl_count++;

	spin_unlock(&dentry_attach_lock);

CRA Git | Maintained and supported by SUSTech CRA and CCSE