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

Commit fc5f499a authored by NeilBrown's avatar NeilBrown Committed by Greg Kroah-Hartman
Browse files

staging: lustre: llite: use more private data in dump_pgcache 



The dump_page_cache debugfs file allocates and frees an 'env' in each
call to vvp_pgcache_start,next,show.  This is likely to be fast, but
does introduce the need to check for errors.

It is reasonable to allocate a single 'env' when the file is opened,
and use that throughout.

So create 'seq_private' structure which stores the sbi, env, and
refcheck, and attach this to the seqfile.

Then use it throughout instead of allocating 'env' repeatedly.

Signed-off-by: default avatarNeilBrown <neilb@suse.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 775c4dc2

drivers/staging/lustre/lustre/llite/vvp_dev.c

+72 −76
Original line number Diff line number Diff line
@@ -390,6 +390,12 @@ struct vvp_pgcache_id { 
	struct lu_object_header *vpi_obj;

};



struct seq_private {

	struct ll_sb_info	*sbi;

	struct lu_env		*env;

	u16			refcheck;

};



static void vvp_pgcache_id_unpack(loff_t pos, struct vvp_pgcache_id *id)

{

	BUILD_BUG_ON(sizeof(pos) != sizeof(__u64));
@@ -531,24 +537,19 @@ static void vvp_pgcache_page_show(const struct lu_env *env, 


static int vvp_pgcache_show(struct seq_file *f, void *v)

{

	struct seq_private	*priv = f->private;

	loff_t		   pos;

	struct ll_sb_info       *sbi;

	struct cl_object	*clob;

	struct lu_env	   *env;

	struct vvp_pgcache_id    id;

	u16 refcheck;

	int		      result;



	env = cl_env_get(&refcheck);

	if (!IS_ERR(env)) {

	pos = *(loff_t *)v;

	vvp_pgcache_id_unpack(pos, &id);

		sbi = f->private;

		clob = vvp_pgcache_obj(env, &sbi->ll_cl->cd_lu_dev, &id);

	clob = vvp_pgcache_obj(priv->env, &priv->sbi->ll_cl->cd_lu_dev, &id);

	if (clob) {

		struct inode *inode = vvp_object_inode(clob);

		struct cl_page *page = NULL;

		struct page *vmpage;

		int result;



		result = find_get_pages_contig(inode->i_mapping,

					       id.vpi_index, 1,
@@ -563,63 +564,45 @@ static int vvp_pgcache_show(struct seq_file *f, void *v) 
		seq_printf(f, "%8x@" DFID ": ", id.vpi_index,

			   PFID(lu_object_fid(&clob->co_lu)));

		if (page) {

				vvp_pgcache_page_show(env, f, page);

				cl_page_put(env, page);

			vvp_pgcache_page_show(priv->env, f, page);

			cl_page_put(priv->env, page);

		} else {

			seq_puts(f, "missing\n");

		}

		lu_object_ref_del(&clob->co_lu, "dump", current);

			cl_object_put(env, clob);

		cl_object_put(priv->env, clob);

	} else {

		seq_printf(f, "%llx missing\n", pos);

	}

		cl_env_put(env, &refcheck);

		result = 0;

	} else {

		result = PTR_ERR(env);

	}

	return result;

	return 0;

}



static void *vvp_pgcache_start(struct seq_file *f, loff_t *pos)

{

	struct ll_sb_info *sbi;

	struct lu_env     *env;

	u16 refcheck;



	sbi = f->private;

	struct seq_private	*priv = f->private;



	env = cl_env_get(&refcheck);

	if (!IS_ERR(env)) {

		sbi = f->private;

		if (sbi->ll_site->ls_obj_hash->hs_cur_bits >

	if (priv->sbi->ll_site->ls_obj_hash->hs_cur_bits >

	    64 - PGC_OBJ_SHIFT) {

		pos = ERR_PTR(-EFBIG);

	} else {

			*pos = vvp_pgcache_find(env, &sbi->ll_cl->cd_lu_dev,

		*pos = vvp_pgcache_find(priv->env, &priv->sbi->ll_cl->cd_lu_dev,

					*pos);

		if (*pos == ~0ULL)

			pos = NULL;

	}

		cl_env_put(env, &refcheck);

	}



	return pos;

}



static void *vvp_pgcache_next(struct seq_file *f, void *v, loff_t *pos)

{

	struct ll_sb_info *sbi;

	struct lu_env     *env;

	u16 refcheck;

	struct seq_private *priv = f->private;



	env = cl_env_get(&refcheck);

	if (!IS_ERR(env)) {

		sbi = f->private;

		*pos = vvp_pgcache_find(env, &sbi->ll_cl->cd_lu_dev, *pos + 1);

	*pos = vvp_pgcache_find(priv->env, &priv->sbi->ll_cl->cd_lu_dev,

				*pos + 1);

	if (*pos == ~0ULL)

		pos = NULL;

		cl_env_put(env, &refcheck);

	}



	return pos;

}
@@ -637,23 +620,36 @@ static const struct seq_operations vvp_pgcache_ops = { 


static int vvp_dump_pgcache_seq_open(struct inode *inode, struct file *filp)

{

	struct seq_file *seq;

	int rc;

	struct seq_private *priv;



	rc = seq_open(filp, &vvp_pgcache_ops);

	if (rc)

		return rc;

	priv = __seq_open_private(filp, &vvp_pgcache_ops, sizeof(*priv));

	if (!priv)

		return -ENOMEM;



	seq = filp->private_data;

	seq->private = inode->i_private;

	priv->sbi = inode->i_private;

	priv->env = cl_env_get(&priv->refcheck);

	if (IS_ERR(priv->env)) {

		int err = PTR_ERR(priv->env);



		seq_release_private(inode, filp);

		return err;

	}

	return 0;

}



static int vvp_dump_pgcache_seq_release(struct inode *inode, struct file *file)

{

	struct seq_file *seq = file->private_data;

	struct seq_private *priv = seq->private;



	cl_env_put(priv->env, &priv->refcheck);

	return seq_release_private(inode, file);

}



const struct file_operations vvp_dump_pgcache_file_ops = {

	.owner   = THIS_MODULE,

	.open    = vvp_dump_pgcache_seq_open,

	.read    = seq_read,

	.llseek	 = seq_lseek,

	.release = seq_release,

	.release = vvp_dump_pgcache_seq_release,

};