| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Date: Fri, 31 Aug 2018 16:14:27 +0200
From: Matias Bjørling <mb@...htnvm.io>
To: hans.ml.holmberg@...tronix.com
Cc: linux-block@...r.kernel.org, linux-kernel@...r.kernel.org,
javier@...xlabs.com, hans.holmberg@...xlabs.com
Subject: Re: [PATCH] lightnvm: pblk: stop recreating global caches
On 08/31/2018 11:59 AM, Hans Holmberg wrote:
> From: Hans Holmberg <hans.holmberg@...xlabs.com>
>
> Pblk should not create a set of global caches every time
> a pblk instance is created. The global caches should be
> made available only when there is one or more pblk instances.
>
> This patch bundles the global caches together with a kref
> keeping track of whether the caches should be available or not.
>
> Signed-off-by: Hans Holmberg <hans.holmberg@...xlabs.com>
> ---
> drivers/lightnvm/pblk-init.c | 113 ++++++++++++++++++++++++++-----------------
> 1 file changed, 68 insertions(+), 45 deletions(-)
>
> diff --git a/drivers/lightnvm/pblk-init.c b/drivers/lightnvm/pblk-init.c
> index 9aebdee8e4c9..e2cdd840e7d0 100644
> --- a/drivers/lightnvm/pblk-init.c
> +++ b/drivers/lightnvm/pblk-init.c
> @@ -26,9 +26,19 @@ static unsigned int write_buffer_size;
> module_param(write_buffer_size, uint, 0644);
> MODULE_PARM_DESC(write_buffer_size, "number of entries in a write buffer");
>
> -static struct kmem_cache *pblk_ws_cache, *pblk_rec_cache, *pblk_g_rq_cache,
> - *pblk_w_rq_cache;
> -static DECLARE_RWSEM(pblk_lock);
> +struct pblk_global_caches {
How about pblk_caches?
> + struct kmem_cache *ws_cache;
> + struct kmem_cache *rec_cache;
> + struct kmem_cache *g_rq_cache;
> + struct kmem_cache *w_rq_cache;
You can drop _cache from the names now that its implicit from the structure.
> + struct kref kref;
> +};
> +
> +static struct pblk_global_caches caches = {
g_caches? pblk_caches?
> + .kref = KREF_INIT(0)
> +};
> +
> +static DECLARE_RWSEM(pblk_lock); /* Protects global caches */
pblk_caches_lock? and consider just using a semaphore, we don't need
separate readers and writers for this.
> struct bio_set pblk_bio_set;
>
> static int pblk_rw_io(struct request_queue *q, struct pblk *pblk,
> @@ -307,53 +317,68 @@ static int pblk_set_addrf(struct pblk *pblk)
> return 0;
> }
>
> -static int pblk_init_global_caches(struct pblk *pblk)
> +static int pblk_get_global_caches(void)
Looks like what this one does is initializing the caches. I get the
get/put concept, but you may want to split it into two other functions.
Such that you have
pblk_init_caches() (only called by pblk_get_caches)
and
pblk_get_caches()
{
down(&pblk_cache_sem);
if (kref_read(&caches.kref) > 0) {
down(&pblk_cache_sem);
return 0;
}
ret = pblk_init_caches(..);
up(&pblk_cache_sem);
return ret;
}
> {
> down_write(&pblk_lock);
> - pblk_ws_cache = kmem_cache_create("pblk_blk_ws",
> +
> + if (kref_read(&caches.kref) > 0)
> + goto caches_available;
> +
> + caches.ws_cache = kmem_cache_create("pblk_blk_ws",
> sizeof(struct pblk_line_ws), 0, 0, NULL);
> - if (!pblk_ws_cache) {
> - up_write(&pblk_lock);
> - return -ENOMEM;
> - }
> + if (!caches.ws_cache)
> + goto fail;
>
> - pblk_rec_cache = kmem_cache_create("pblk_rec",
> + caches.rec_cache = kmem_cache_create("pblk_rec",
> sizeof(struct pblk_rec_ctx), 0, 0, NULL);
> - if (!pblk_rec_cache) {
> - kmem_cache_destroy(pblk_ws_cache);
> - up_write(&pblk_lock);
> - return -ENOMEM;
> - }
> + if (!caches.rec_cache)
> + goto fail_destroy_ws_cache;
>
> - pblk_g_rq_cache = kmem_cache_create("pblk_g_rq", pblk_g_rq_size,
> + caches.g_rq_cache = kmem_cache_create("pblk_g_rq", pblk_g_rq_size,
> 0, 0, NULL);
> - if (!pblk_g_rq_cache) {
> - kmem_cache_destroy(pblk_ws_cache);
> - kmem_cache_destroy(pblk_rec_cache);
> - up_write(&pblk_lock);
> - return -ENOMEM;
> - }
> + if (!caches.g_rq_cache)
> + goto fail_destroy_rec_cache;
>
> - pblk_w_rq_cache = kmem_cache_create("pblk_w_rq", pblk_w_rq_size,
> + caches.w_rq_cache = kmem_cache_create("pblk_w_rq", pblk_w_rq_size,
> 0, 0, NULL);
> - if (!pblk_w_rq_cache) {
> - kmem_cache_destroy(pblk_ws_cache);
> - kmem_cache_destroy(pblk_rec_cache);
> - kmem_cache_destroy(pblk_g_rq_cache);
> - up_write(&pblk_lock);
> - return -ENOMEM;
> - }
> + if (!caches.w_rq_cache)
> + goto fail_destroy_g_rq_cache;
> +
> +caches_available:
> + kref_get(&caches.kref);
> up_write(&pblk_lock);
>
> return 0;
> +
> +fail_destroy_g_rq_cache:
> + kmem_cache_destroy(caches.g_rq_cache);
> +fail_destroy_rec_cache:
> + kmem_cache_destroy(caches.rec_cache);
> +fail_destroy_ws_cache:
> + kmem_cache_destroy(caches.ws_cache);
> +fail:
> + up_write(&pblk_lock);
> +
> + return -ENOMEM;
> }
>
> -static void pblk_free_global_caches(struct pblk *pblk)
> +static void pblk_destroy_global_caches(struct kref *ref)
> {
> - kmem_cache_destroy(pblk_ws_cache);
> - kmem_cache_destroy(pblk_rec_cache);
> - kmem_cache_destroy(pblk_g_rq_cache);
> - kmem_cache_destroy(pblk_w_rq_cache);
> + struct pblk_global_caches *c;
> +
> + c = container_of(ref, struct pblk_global_caches, kref);
> +
> + kmem_cache_destroy(c->ws_cache);
> + kmem_cache_destroy(c->rec_cache);
> + kmem_cache_destroy(c->g_rq_cache);
> + kmem_cache_destroy(c->w_rq_cache);
> +}
> +
> +static void pblk_put_global_caches(void)
> +{
> + down_write(&pblk_lock);
> + kref_put(&caches.kref, pblk_destroy_global_caches);
> + up_write(&pblk_lock);
> }
>
> static int pblk_core_init(struct pblk *pblk)
> @@ -382,7 +407,7 @@ static int pblk_core_init(struct pblk *pblk)
> if (!pblk->pad_dist)
> return -ENOMEM;
>
> - if (pblk_init_global_caches(pblk))
> + if (pblk_get_global_caches())
> goto fail_free_pad_dist;
>
> /* Internal bios can be at most the sectors signaled by the device. */
> @@ -391,27 +416,27 @@ static int pblk_core_init(struct pblk *pblk)
> goto free_global_caches;
>
> ret = mempool_init_slab_pool(&pblk->gen_ws_pool, PBLK_GEN_WS_POOL_SIZE,
> - pblk_ws_cache);
> + caches.ws_cache);
> if (ret)
> goto free_page_bio_pool;
>
> ret = mempool_init_slab_pool(&pblk->rec_pool, geo->all_luns,
> - pblk_rec_cache);
> + caches.rec_cache);
> if (ret)
> goto free_gen_ws_pool;
>
> ret = mempool_init_slab_pool(&pblk->r_rq_pool, geo->all_luns,
> - pblk_g_rq_cache);
> + caches.g_rq_cache);
> if (ret)
> goto free_rec_pool;
>
> ret = mempool_init_slab_pool(&pblk->e_rq_pool, geo->all_luns,
> - pblk_g_rq_cache);
> + caches.g_rq_cache);
> if (ret)
> goto free_r_rq_pool;
>
> ret = mempool_init_slab_pool(&pblk->w_rq_pool, geo->all_luns,
> - pblk_w_rq_cache);
> + caches.w_rq_cache);
> if (ret)
> goto free_e_rq_pool;
>
> @@ -457,7 +482,7 @@ static int pblk_core_init(struct pblk *pblk)
> free_page_bio_pool:
> mempool_exit(&pblk->page_bio_pool);
> free_global_caches:
> - pblk_free_global_caches(pblk);
> + pblk_put_global_caches();
> fail_free_pad_dist:
> kfree(pblk->pad_dist);
> return -ENOMEM;
> @@ -481,7 +506,7 @@ static void pblk_core_free(struct pblk *pblk)
> mempool_exit(&pblk->e_rq_pool);
> mempool_exit(&pblk->w_rq_pool);
>
> - pblk_free_global_caches(pblk);
> + pblk_put_global_caches();
> kfree(pblk->pad_dist);
> }
>
> @@ -1074,7 +1099,6 @@ static void pblk_exit(void *private, bool graceful)
> {
> struct pblk *pblk = private;
>
> - down_write(&pblk_lock);
> pblk_gc_exit(pblk, graceful);
> pblk_tear_down(pblk, graceful);
>
> @@ -1083,7 +1107,6 @@ static void pblk_exit(void *private, bool graceful)
> #endif
>
> pblk_free(pblk);
> - up_write(&pblk_lock);
> }
>
> static sector_t pblk_capacity(void *private)
>
Powered by blists - more mailing lists