[linux.git] / block / blk-integrity.c

/*
 * blk-integrity.c - Block layer data integrity extensions
 *
 * Copyright (C) 2007, 2008 Oracle Corporation
 * Written by: Martin K. Petersen <[email protected]>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; see the file COPYING.  If not, write to
 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
 * USA.
 *
 */

#include <linux/blkdev.h>
#include <linux/mempool.h>
#include <linux/bio.h>
#include <linux/scatterlist.h>
#include <linux/export.h>
#include <linux/slab.h>

#include "blk.h"

static struct kmem_cache *integrity_cachep;

static const char *bi_unsupported_name = "unsupported";

/**
 * blk_rq_count_integrity_sg - Count number of integrity scatterlist elements
 * @q:		request queue
 * @bio:	bio with integrity metadata attached
 *
 * Description: Returns the number of elements required in a
 * scatterlist corresponding to the integrity metadata in a bio.
 */
int blk_rq_count_integrity_sg(struct request_queue *q, struct bio *bio)
{
	struct bio_vec iv, ivprv = { NULL };
	unsigned int segments = 0;
	unsigned int seg_size = 0;
	struct bvec_iter iter;
	int prev = 0;

	bio_for_each_integrity_vec(iv, bio, iter) {

		if (prev) {
			if (!BIOVEC_PHYS_MERGEABLE(&ivprv, &iv))
				goto new_segment;

			if (!BIOVEC_SEG_BOUNDARY(q, &ivprv, &iv))
				goto new_segment;

			if (seg_size + iv.bv_len > queue_max_segment_size(q))
				goto new_segment;

			seg_size += iv.bv_len;
		} else {
new_segment:
			segments++;
			seg_size = iv.bv_len;
		}

		prev = 1;
		ivprv = iv;
	}

	return segments;
}
EXPORT_SYMBOL(blk_rq_count_integrity_sg);

/**
 * blk_rq_map_integrity_sg - Map integrity metadata into a scatterlist
 * @q:		request queue
 * @bio:	bio with integrity metadata attached
 * @sglist:	target scatterlist
 *
 * Description: Map the integrity vectors in request into a
 * scatterlist.  The scatterlist must be big enough to hold all
 * elements.  I.e. sized using blk_rq_count_integrity_sg().
 */
int blk_rq_map_integrity_sg(struct request_queue *q, struct bio *bio,
			    struct scatterlist *sglist)
{
	struct bio_vec iv, ivprv = { NULL };
	struct scatterlist *sg = NULL;
	unsigned int segments = 0;
	struct bvec_iter iter;
	int prev = 0;

	bio_for_each_integrity_vec(iv, bio, iter) {

		if (prev) {
			if (!BIOVEC_PHYS_MERGEABLE(&ivprv, &iv))
				goto new_segment;

			if (!BIOVEC_SEG_BOUNDARY(q, &ivprv, &iv))
				goto new_segment;

			if (sg->length + iv.bv_len > queue_max_segment_size(q))
				goto new_segment;

			sg->length += iv.bv_len;
		} else {
new_segment:
			if (!sg)
				sg = sglist;
			else {
				sg_unmark_end(sg);
				sg = sg_next(sg);
			}

			sg_set_page(sg, iv.bv_page, iv.bv_len, iv.bv_offset);
			segments++;
		}

		prev = 1;
		ivprv = iv;
	}

	if (sg)
		sg_mark_end(sg);

	return segments;
}
EXPORT_SYMBOL(blk_rq_map_integrity_sg);

/**
 * blk_integrity_compare - Compare integrity profile of two disks
 * @gd1:	Disk to compare
 * @gd2:	Disk to compare
 *
 * Description: Meta-devices like DM and MD need to verify that all
 * sub-devices use the same integrity format before advertising to
 * upper layers that they can send/receive integrity metadata.  This
 * function can be used to check whether two gendisk devices have
 * compatible integrity formats.
 */
int blk_integrity_compare(struct gendisk *gd1, struct gendisk *gd2)
{
	struct blk_integrity *b1 = gd1->integrity;
	struct blk_integrity *b2 = gd2->integrity;

	if (!b1 && !b2)
		return 0;

	if (!b1 || !b2)
		return -1;

	if (b1->sector_size != b2->sector_size) {
		printk(KERN_ERR "%s: %s/%s sector sz %u != %u\n", __func__,
		       gd1->disk_name, gd2->disk_name,
		       b1->sector_size, b2->sector_size);
		return -1;
	}

	if (b1->tuple_size != b2->tuple_size) {
		printk(KERN_ERR "%s: %s/%s tuple sz %u != %u\n", __func__,
		       gd1->disk_name, gd2->disk_name,
		       b1->tuple_size, b2->tuple_size);
		return -1;
	}

	if (b1->tag_size && b2->tag_size && (b1->tag_size != b2->tag_size)) {
		printk(KERN_ERR "%s: %s/%s tag sz %u != %u\n", __func__,
		       gd1->disk_name, gd2->disk_name,
		       b1->tag_size, b2->tag_size);
		return -1;
	}

	if (strcmp(b1->name, b2->name)) {
		printk(KERN_ERR "%s: %s/%s type %s != %s\n", __func__,
		       gd1->disk_name, gd2->disk_name,
		       b1->name, b2->name);
		return -1;
	}

	return 0;
}
EXPORT_SYMBOL(blk_integrity_compare);

int blk_integrity_merge_rq(struct request_queue *q, struct request *req,
			   struct request *next)
{
	if (blk_integrity_rq(req) != blk_integrity_rq(next))
		return -1;

	if (req->nr_integrity_segments + next->nr_integrity_segments >
	    q->limits.max_integrity_segments)
		return -1;

	return 0;
}
EXPORT_SYMBOL(blk_integrity_merge_rq);

int blk_integrity_merge_bio(struct request_queue *q, struct request *req,
			    struct bio *bio)
{
	int nr_integrity_segs;
	struct bio *next = bio->bi_next;

	bio->bi_next = NULL;
	nr_integrity_segs = blk_rq_count_integrity_sg(q, bio);
	bio->bi_next = next;

	if (req->nr_integrity_segments + nr_integrity_segs >
	    q->limits.max_integrity_segments)
		return -1;

	req->nr_integrity_segments += nr_integrity_segs;

	return 0;
}
EXPORT_SYMBOL(blk_integrity_merge_bio);

struct integrity_sysfs_entry {
	struct attribute attr;
	ssize_t (*show)(struct blk_integrity *, char *);
	ssize_t (*store)(struct blk_integrity *, const char *, size_t);
};

static ssize_t integrity_attr_show(struct kobject *kobj, struct attribute *attr,
				   char *page)
{
	struct blk_integrity *bi =
		container_of(kobj, struct blk_integrity, kobj);
	struct integrity_sysfs_entry *entry =
		container_of(attr, struct integrity_sysfs_entry, attr);

	return entry->show(bi, page);
}

static ssize_t integrity_attr_store(struct kobject *kobj,
				    struct attribute *attr, const char *page,
				    size_t count)
{
	struct blk_integrity *bi =
		container_of(kobj, struct blk_integrity, kobj);
	struct integrity_sysfs_entry *entry =
		container_of(attr, struct integrity_sysfs_entry, attr);
	ssize_t ret = 0;

	if (entry->store)
		ret = entry->store(bi, page, count);

	return ret;
}

static ssize_t integrity_format_show(struct blk_integrity *bi, char *page)
{
	if (bi != NULL && bi->name != NULL)
		return sprintf(page, "%s\n", bi->name);
	else
		return sprintf(page, "none\n");
}

static ssize_t integrity_tag_size_show(struct blk_integrity *bi, char *page)
{
	if (bi != NULL)
		return sprintf(page, "%u\n", bi->tag_size);
	else
		return sprintf(page, "0\n");
}

static ssize_t integrity_read_store(struct blk_integrity *bi,
				    const char *page, size_t count)
{
	char *p = (char *) page;
	unsigned long val = simple_strtoul(p, &p, 10);

	if (val)
		bi->flags |= INTEGRITY_FLAG_READ;
	else
		bi->flags &= ~INTEGRITY_FLAG_READ;

	return count;
}

static ssize_t integrity_read_show(struct blk_integrity *bi, char *page)
{
	return sprintf(page, "%d\n", (bi->flags & INTEGRITY_FLAG_READ) != 0);
}

static ssize_t integrity_write_store(struct blk_integrity *bi,
				     const char *page, size_t count)
{
	char *p = (char *) page;
	unsigned long val = simple_strtoul(p, &p, 10);

	if (val)
		bi->flags |= INTEGRITY_FLAG_WRITE;
	else
		bi->flags &= ~INTEGRITY_FLAG_WRITE;

	return count;
}

static ssize_t integrity_write_show(struct blk_integrity *bi, char *page)
{
	return sprintf(page, "%d\n", (bi->flags & INTEGRITY_FLAG_WRITE) != 0);
}

static struct integrity_sysfs_entry integrity_format_entry = {
	.attr = { .name = "format", .mode = S_IRUGO },
	.show = integrity_format_show,
};

static struct integrity_sysfs_entry integrity_tag_size_entry = {
	.attr = { .name = "tag_size", .mode = S_IRUGO },
	.show = integrity_tag_size_show,
};

static struct integrity_sysfs_entry integrity_read_entry = {
	.attr = { .name = "read_verify", .mode = S_IRUGO | S_IWUSR },
	.show = integrity_read_show,
	.store = integrity_read_store,
};

static struct integrity_sysfs_entry integrity_write_entry = {
	.attr = { .name = "write_generate", .mode = S_IRUGO | S_IWUSR },
	.show = integrity_write_show,
	.store = integrity_write_store,
};

static struct attribute *integrity_attrs[] = {
	&integrity_format_entry.attr,
	&integrity_tag_size_entry.attr,
	&integrity_read_entry.attr,
	&integrity_write_entry.attr,
	NULL,
};

static const struct sysfs_ops integrity_ops = {
	.show	= &integrity_attr_show,
	.store	= &integrity_attr_store,
};

static int __init blk_dev_integrity_init(void)
{
	integrity_cachep = kmem_cache_create("blkdev_integrity",
					     sizeof(struct blk_integrity),
					     0, SLAB_PANIC, NULL);
	return 0;
}
subsys_initcall(blk_dev_integrity_init);

static void blk_integrity_release(struct kobject *kobj)
{
	struct blk_integrity *bi =
		container_of(kobj, struct blk_integrity, kobj);

	kmem_cache_free(integrity_cachep, bi);
}

static struct kobj_type integrity_ktype = {
	.default_attrs	= integrity_attrs,
	.sysfs_ops	= &integrity_ops,
	.release	= blk_integrity_release,
};

bool blk_integrity_is_initialized(struct gendisk *disk)
{
	struct blk_integrity *bi = blk_get_integrity(disk);

	return (bi && bi->name && strcmp(bi->name, bi_unsupported_name) != 0);
}
EXPORT_SYMBOL(blk_integrity_is_initialized);

/**
 * blk_integrity_register - Register a gendisk as being integrity-capable
 * @disk:	struct gendisk pointer to make integrity-aware
 * @template:	optional integrity profile to register
 *
 * Description: When a device needs to advertise itself as being able
 * to send/receive integrity metadata it must use this function to
 * register the capability with the block layer.  The template is a
 * blk_integrity struct with values appropriate for the underlying
 * hardware.  If template is NULL the new profile is allocated but
 * not filled out. See Documentation/block/data-integrity.txt.
 */
int blk_integrity_register(struct gendisk *disk, struct blk_integrity *template)
{
	struct blk_integrity *bi;

	BUG_ON(disk == NULL);

	if (disk->integrity == NULL) {
		bi = kmem_cache_alloc(integrity_cachep,
				      GFP_KERNEL | __GFP_ZERO);
		if (!bi)
			return -1;

		if (kobject_init_and_add(&bi->kobj, &integrity_ktype,
					 &disk_to_dev(disk)->kobj,
					 "%s", "integrity")) {
			kmem_cache_free(integrity_cachep, bi);
			return -1;
		}

		kobject_uevent(&bi->kobj, KOBJ_ADD);

		bi->flags |= INTEGRITY_FLAG_READ | INTEGRITY_FLAG_WRITE;
		bi->sector_size = queue_logical_block_size(disk->queue);
		disk->integrity = bi;
	} else
		bi = disk->integrity;

	/* Use the provided profile as template */
	if (template != NULL) {
		bi->name = template->name;
		bi->generate_fn = template->generate_fn;
		bi->verify_fn = template->verify_fn;
		bi->tuple_size = template->tuple_size;
		bi->set_tag_fn = template->set_tag_fn;
		bi->get_tag_fn = template->get_tag_fn;
		bi->tag_size = template->tag_size;
	} else
		bi->name = bi_unsupported_name;

	disk->queue->backing_dev_info.capabilities |= BDI_CAP_STABLE_WRITES;

	return 0;
}
EXPORT_SYMBOL(blk_integrity_register);

/**
 * blk_integrity_unregister - Remove block integrity profile
 * @disk:	disk whose integrity profile to deallocate
 *
 * Description: This function frees all memory used by the block
 * integrity profile.  To be called at device teardown.
 */
void blk_integrity_unregister(struct gendisk *disk)
{
	struct blk_integrity *bi;

	if (!disk || !disk->integrity)
		return;

	disk->queue->backing_dev_info.capabilities &= ~BDI_CAP_STABLE_WRITES;

	bi = disk->integrity;

	kobject_uevent(&bi->kobj, KOBJ_REMOVE);
	kobject_del(&bi->kobj);
	kobject_put(&bi->kobj);
	disk->integrity = NULL;
}
EXPORT_SYMBOL(blk_integrity_unregister);
Commit	Line	Data
7ba1ba12 MP	1	/*
	2	* blk-integrity.c - Block layer data integrity extensions
	3	*
	4	* Copyright (C) 2007, 2008 Oracle Corporation
	5	* Written by: Martin K. Petersen <[email protected]>
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License version
	9	* 2 as published by the Free Software Foundation.
	10	*
	11	* This program is distributed in the hope that it will be useful, but
	12	* WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; see the file COPYING. If not, write to
	18	* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
	19	* USA.
	20	*
	21	*/
	22
	23	#include <linux/blkdev.h>
	24	#include <linux/mempool.h>
	25	#include <linux/bio.h>
	26	#include <linux/scatterlist.h>
d5decd3b	27	#include <linux/export.h>
5a0e3ad6	28	#include <linux/slab.h>
7ba1ba12 MP	29
	30	#include "blk.h"
	31
	32	static struct kmem_cache *integrity_cachep;
	33
a63a5cf8 MS	34	static const char *bi_unsupported_name = "unsupported";
a63a5cf8 MS	35
7ba1ba12 MP	36	/**
7ba1ba12 MP	37	* blk_rq_count_integrity_sg - Count number of integrity scatterlist elements
13f05c8d MP	38	* @q: request queue
13f05c8d MP	39	* @bio: bio with integrity metadata attached
7ba1ba12 MP	40	*
7ba1ba12 MP	41	* Description: Returns the number of elements required in a
13f05c8d	42	* scatterlist corresponding to the integrity metadata in a bio.
7ba1ba12	43	*/
13f05c8d	44	int blk_rq_count_integrity_sg(struct request_queue q, struct bio bio)
7ba1ba12	45	{
d57a5f7c	46	struct bio_vec iv, ivprv = { NULL };
13f05c8d MP	47	unsigned int segments = 0;
13f05c8d MP	48	unsigned int seg_size = 0;
d57a5f7c KO	49	struct bvec_iter iter;
d57a5f7c KO	50	int prev = 0;
7ba1ba12	51
d57a5f7c	52	bio_for_each_integrity_vec(iv, bio, iter) {
7ba1ba12	53
d57a5f7c KO	54	if (prev) {
d57a5f7c KO	55	if (!BIOVEC_PHYS_MERGEABLE(&ivprv, &iv))
13f05c8d MP	56	goto new_segment;
13f05c8d MP	57
d57a5f7c	58	if (!BIOVEC_SEG_BOUNDARY(q, &ivprv, &iv))
13f05c8d MP	59	goto new_segment;
13f05c8d MP	60
d57a5f7c	61	if (seg_size + iv.bv_len > queue_max_segment_size(q))
13f05c8d	62	goto new_segment;
7ba1ba12	63
d57a5f7c	64	seg_size += iv.bv_len;
13f05c8d MP	65	} else {
13f05c8d MP	66	new_segment:
7ba1ba12	67	segments++;
d57a5f7c	68	seg_size = iv.bv_len;
13f05c8d	69	}
7ba1ba12	70
d57a5f7c	71	prev = 1;
7ba1ba12 MP	72	ivprv = iv;
	73	}
	74
	75	return segments;
	76	}
	77	EXPORT_SYMBOL(blk_rq_count_integrity_sg);
	78
	79	/**
	80	* blk_rq_map_integrity_sg - Map integrity metadata into a scatterlist
13f05c8d MP	81	* @q: request queue
13f05c8d MP	82	* @bio: bio with integrity metadata attached
7ba1ba12 MP	83	* @sglist: target scatterlist
	84	*
	85	* Description: Map the integrity vectors in request into a
	86	* scatterlist. The scatterlist must be big enough to hold all
	87	* elements. I.e. sized using blk_rq_count_integrity_sg().
	88	*/
13f05c8d MP	89	int blk_rq_map_integrity_sg(struct request_queue q, struct bio bio,
13f05c8d MP	90	struct scatterlist *sglist)
7ba1ba12	91	{
d57a5f7c	92	struct bio_vec iv, ivprv = { NULL };
13f05c8d MP	93	struct scatterlist *sg = NULL;
13f05c8d MP	94	unsigned int segments = 0;
d57a5f7c KO	95	struct bvec_iter iter;
d57a5f7c KO	96	int prev = 0;
7ba1ba12	97
d57a5f7c	98	bio_for_each_integrity_vec(iv, bio, iter) {
7ba1ba12	99
d57a5f7c KO	100	if (prev) {
d57a5f7c KO	101	if (!BIOVEC_PHYS_MERGEABLE(&ivprv, &iv))
7ba1ba12 MP	102	goto new_segment;
7ba1ba12 MP	103
d57a5f7c	104	if (!BIOVEC_SEG_BOUNDARY(q, &ivprv, &iv))
13f05c8d MP	105	goto new_segment;
13f05c8d MP	106
d57a5f7c	107	if (sg->length + iv.bv_len > queue_max_segment_size(q))
13f05c8d MP	108	goto new_segment;
13f05c8d MP	109
d57a5f7c	110	sg->length += iv.bv_len;
7ba1ba12 MP	111	} else {
	112	new_segment:
	113	if (!sg)
	114	sg = sglist;
	115	else {
c8164d89	116	sg_unmark_end(sg);
7ba1ba12 MP	117	sg = sg_next(sg);
	118	}
	119
d57a5f7c	120	sg_set_page(sg, iv.bv_page, iv.bv_len, iv.bv_offset);
7ba1ba12 MP	121	segments++;
	122	}
	123
d57a5f7c	124	prev = 1;
7ba1ba12 MP	125	ivprv = iv;
	126	}
	127
	128	if (sg)
	129	sg_mark_end(sg);
	130
	131	return segments;
	132	}
	133	EXPORT_SYMBOL(blk_rq_map_integrity_sg);
	134
	135	/**
ad7fce93 MP	136	* blk_integrity_compare - Compare integrity profile of two disks
	137	* @gd1: Disk to compare
	138	* @gd2: Disk to compare
7ba1ba12 MP	139	*
	140	* Description: Meta-devices like DM and MD need to verify that all
	141	* sub-devices use the same integrity format before advertising to
	142	* upper layers that they can send/receive integrity metadata. This
ad7fce93	143	* function can be used to check whether two gendisk devices have
7ba1ba12 MP	144	* compatible integrity formats.
7ba1ba12 MP	145	*/
ad7fce93	146	int blk_integrity_compare(struct gendisk gd1, struct gendisk gd2)
7ba1ba12	147	{
ad7fce93 MP	148	struct blk_integrity *b1 = gd1->integrity;
ad7fce93 MP	149	struct blk_integrity *b2 = gd2->integrity;
7ba1ba12	150
ad7fce93 MP	151	if (!b1 && !b2)
ad7fce93 MP	152	return 0;
7ba1ba12 MP	153
7ba1ba12 MP	154	if (!b1 \|\| !b2)
ad7fce93	155	return -1;
7ba1ba12 MP	156
	157	if (b1->sector_size != b2->sector_size) {
	158	printk(KERN_ERR "%s: %s/%s sector sz %u != %u\n", __func__,
ad7fce93	159	gd1->disk_name, gd2->disk_name,
7ba1ba12 MP	160	b1->sector_size, b2->sector_size);
	161	return -1;
	162	}
	163
	164	if (b1->tuple_size != b2->tuple_size) {
	165	printk(KERN_ERR "%s: %s/%s tuple sz %u != %u\n", __func__,
ad7fce93	166	gd1->disk_name, gd2->disk_name,
7ba1ba12 MP	167	b1->tuple_size, b2->tuple_size);
	168	return -1;
	169	}
	170
	171	if (b1->tag_size && b2->tag_size && (b1->tag_size != b2->tag_size)) {
	172	printk(KERN_ERR "%s: %s/%s tag sz %u != %u\n", __func__,
ad7fce93	173	gd1->disk_name, gd2->disk_name,
7ba1ba12 MP	174	b1->tag_size, b2->tag_size);
	175	return -1;
	176	}
	177
	178	if (strcmp(b1->name, b2->name)) {
	179	printk(KERN_ERR "%s: %s/%s type %s != %s\n", __func__,
ad7fce93	180	gd1->disk_name, gd2->disk_name,
7ba1ba12 MP	181	b1->name, b2->name);
	182	return -1;
	183	}
	184
	185	return 0;
	186	}
	187	EXPORT_SYMBOL(blk_integrity_compare);
	188
13f05c8d MP	189	int blk_integrity_merge_rq(struct request_queue q, struct request req,
	190	struct request *next)
	191	{
	192	if (blk_integrity_rq(req) != blk_integrity_rq(next))
	193	return -1;
	194
	195	if (req->nr_integrity_segments + next->nr_integrity_segments >
	196	q->limits.max_integrity_segments)
	197	return -1;
	198
	199	return 0;
	200	}
	201	EXPORT_SYMBOL(blk_integrity_merge_rq);
	202
	203	int blk_integrity_merge_bio(struct request_queue q, struct request req,
	204	struct bio *bio)
	205	{
	206	int nr_integrity_segs;
	207	struct bio *next = bio->bi_next;
	208
	209	bio->bi_next = NULL;
	210	nr_integrity_segs = blk_rq_count_integrity_sg(q, bio);
	211	bio->bi_next = next;
	212
	213	if (req->nr_integrity_segments + nr_integrity_segs >
	214	q->limits.max_integrity_segments)
	215	return -1;
	216
	217	req->nr_integrity_segments += nr_integrity_segs;
	218
	219	return 0;
	220	}
	221	EXPORT_SYMBOL(blk_integrity_merge_bio);
	222
7ba1ba12 MP	223	struct integrity_sysfs_entry {
	224	struct attribute attr;
	225	ssize_t (show)(struct blk_integrity , char *);
	226	ssize_t (store)(struct blk_integrity , const char *, size_t);
	227	};
	228
	229	static ssize_t integrity_attr_show(struct kobject kobj, struct attribute attr,
	230	char *page)
	231	{
	232	struct blk_integrity *bi =
	233	container_of(kobj, struct blk_integrity, kobj);
	234	struct integrity_sysfs_entry *entry =
	235	container_of(attr, struct integrity_sysfs_entry, attr);
	236
	237	return entry->show(bi, page);
	238	}
	239
b984679e JA	240	static ssize_t integrity_attr_store(struct kobject *kobj,
	241	struct attribute attr, const char page,
	242	size_t count)
7ba1ba12 MP	243	{
	244	struct blk_integrity *bi =
	245	container_of(kobj, struct blk_integrity, kobj);
	246	struct integrity_sysfs_entry *entry =
	247	container_of(attr, struct integrity_sysfs_entry, attr);
	248	ssize_t ret = 0;
	249
	250	if (entry->store)
	251	ret = entry->store(bi, page, count);
	252
	253	return ret;
	254	}
	255
	256	static ssize_t integrity_format_show(struct blk_integrity bi, char page)
	257	{
	258	if (bi != NULL && bi->name != NULL)
	259	return sprintf(page, "%s\n", bi->name);
	260	else
	261	return sprintf(page, "none\n");
	262	}
	263
	264	static ssize_t integrity_tag_size_show(struct blk_integrity bi, char page)
	265	{
	266	if (bi != NULL)
	267	return sprintf(page, "%u\n", bi->tag_size);
	268	else
	269	return sprintf(page, "0\n");
	270	}
	271
	272	static ssize_t integrity_read_store(struct blk_integrity *bi,
	273	const char *page, size_t count)
	274	{
	275	char p = (char ) page;
	276	unsigned long val = simple_strtoul(p, &p, 10);
	277
	278	if (val)
b24498d4	279	bi->flags \|= INTEGRITY_FLAG_READ;
7ba1ba12	280	else
b24498d4	281	bi->flags &= ~INTEGRITY_FLAG_READ;
7ba1ba12 MP	282
	283	return count;
	284	}
	285
	286	static ssize_t integrity_read_show(struct blk_integrity bi, char page)
	287	{
b24498d4	288	return sprintf(page, "%d\n", (bi->flags & INTEGRITY_FLAG_READ) != 0);
7ba1ba12 MP	289	}
	290
	291	static ssize_t integrity_write_store(struct blk_integrity *bi,
	292	const char *page, size_t count)
	293	{
	294	char p = (char ) page;
	295	unsigned long val = simple_strtoul(p, &p, 10);
	296
	297	if (val)
b24498d4	298	bi->flags \|= INTEGRITY_FLAG_WRITE;
7ba1ba12	299	else
b24498d4	300	bi->flags &= ~INTEGRITY_FLAG_WRITE;
7ba1ba12 MP	301
	302	return count;
	303	}
	304
	305	static ssize_t integrity_write_show(struct blk_integrity bi, char page)
	306	{
b24498d4	307	return sprintf(page, "%d\n", (bi->flags & INTEGRITY_FLAG_WRITE) != 0);
7ba1ba12 MP	308	}
	309
	310	static struct integrity_sysfs_entry integrity_format_entry = {
	311	.attr = { .name = "format", .mode = S_IRUGO },
	312	.show = integrity_format_show,
	313	};
	314
	315	static struct integrity_sysfs_entry integrity_tag_size_entry = {
	316	.attr = { .name = "tag_size", .mode = S_IRUGO },
	317	.show = integrity_tag_size_show,
	318	};
	319
	320	static struct integrity_sysfs_entry integrity_read_entry = {
	321	.attr = { .name = "read_verify", .mode = S_IRUGO \| S_IWUSR },
	322	.show = integrity_read_show,
	323	.store = integrity_read_store,
	324	};
	325
	326	static struct integrity_sysfs_entry integrity_write_entry = {
	327	.attr = { .name = "write_generate", .mode = S_IRUGO \| S_IWUSR },
	328	.show = integrity_write_show,
	329	.store = integrity_write_store,
	330	};
	331
	332	static struct attribute *integrity_attrs[] = {
	333	&integrity_format_entry.attr,
	334	&integrity_tag_size_entry.attr,
	335	&integrity_read_entry.attr,
	336	&integrity_write_entry.attr,
	337	NULL,
	338	};
	339
52cf25d0	340	static const struct sysfs_ops integrity_ops = {
7ba1ba12 MP	341	.show = &integrity_attr_show,
	342	.store = &integrity_attr_store,
	343	};
	344
	345	static int __init blk_dev_integrity_init(void)
	346	{
	347	integrity_cachep = kmem_cache_create("blkdev_integrity",
	348	sizeof(struct blk_integrity),
	349	0, SLAB_PANIC, NULL);
	350	return 0;
	351	}
	352	subsys_initcall(blk_dev_integrity_init);
	353
	354	static void blk_integrity_release(struct kobject *kobj)
	355	{
	356	struct blk_integrity *bi =
	357	container_of(kobj, struct blk_integrity, kobj);
	358
	359	kmem_cache_free(integrity_cachep, bi);
	360	}
	361
	362	static struct kobj_type integrity_ktype = {
	363	.default_attrs = integrity_attrs,
	364	.sysfs_ops = &integrity_ops,
	365	.release = blk_integrity_release,
	366	};
	367
a63a5cf8 MS	368	bool blk_integrity_is_initialized(struct gendisk *disk)
	369	{
	370	struct blk_integrity *bi = blk_get_integrity(disk);
	371
	372	return (bi && bi->name && strcmp(bi->name, bi_unsupported_name) != 0);
	373	}
	374	EXPORT_SYMBOL(blk_integrity_is_initialized);
	375
7ba1ba12 MP	376	/**
	377	* blk_integrity_register - Register a gendisk as being integrity-capable
	378	* @disk: struct gendisk pointer to make integrity-aware
32231638	379	* @template: optional integrity profile to register
7ba1ba12 MP	380	*
	381	* Description: When a device needs to advertise itself as being able
	382	* to send/receive integrity metadata it must use this function to
	383	* register the capability with the block layer. The template is a
	384	* blk_integrity struct with values appropriate for the underlying
32231638 MP	385	* hardware. If template is NULL the new profile is allocated but
32231638 MP	386	* not filled out. See Documentation/block/data-integrity.txt.
7ba1ba12 MP	387	*/
	388	int blk_integrity_register(struct gendisk disk, struct blk_integrity template)
	389	{
	390	struct blk_integrity *bi;
	391
	392	BUG_ON(disk == NULL);
7ba1ba12 MP	393
7ba1ba12 MP	394	if (disk->integrity == NULL) {
b984679e	395	bi = kmem_cache_alloc(integrity_cachep,
32231638	396	GFP_KERNEL \| __GFP_ZERO);
7ba1ba12 MP	397	if (!bi)
	398	return -1;
	399
	400	if (kobject_init_and_add(&bi->kobj, &integrity_ktype,
ed9e1982 TH	401	&disk_to_dev(disk)->kobj,
ed9e1982 TH	402	"%s", "integrity")) {
7ba1ba12 MP	403	kmem_cache_free(integrity_cachep, bi);
	404	return -1;
	405	}
	406
	407	kobject_uevent(&bi->kobj, KOBJ_ADD);
	408
b24498d4	409	bi->flags \|= INTEGRITY_FLAG_READ \| INTEGRITY_FLAG_WRITE;
e1defc4f	410	bi->sector_size = queue_logical_block_size(disk->queue);
7ba1ba12 MP	411	disk->integrity = bi;
	412	} else
	413	bi = disk->integrity;
	414
	415	/* Use the provided profile as template */
32231638 MP	416	if (template != NULL) {
	417	bi->name = template->name;
	418	bi->generate_fn = template->generate_fn;
	419	bi->verify_fn = template->verify_fn;
	420	bi->tuple_size = template->tuple_size;
	421	bi->set_tag_fn = template->set_tag_fn;
	422	bi->get_tag_fn = template->get_tag_fn;
	423	bi->tag_size = template->tag_size;
	424	} else
a63a5cf8	425	bi->name = bi_unsupported_name;
7ba1ba12	426
7d311cda DW	427	disk->queue->backing_dev_info.capabilities \|= BDI_CAP_STABLE_WRITES;
7d311cda DW	428
7ba1ba12 MP	429	return 0;
	430	}
	431	EXPORT_SYMBOL(blk_integrity_register);
	432
	433	/**
	434	* blk_integrity_unregister - Remove block integrity profile
	435	* @disk: disk whose integrity profile to deallocate
	436	*
	437	* Description: This function frees all memory used by the block
	438	* integrity profile. To be called at device teardown.
	439	*/
	440	void blk_integrity_unregister(struct gendisk *disk)
	441	{
	442	struct blk_integrity *bi;
	443
	444	if (!disk \|\| !disk->integrity)
	445	return;
	446
7d311cda DW	447	disk->queue->backing_dev_info.capabilities &= ~BDI_CAP_STABLE_WRITES;
7d311cda DW	448
7ba1ba12 MP	449	bi = disk->integrity;
	450
	451	kobject_uevent(&bi->kobj, KOBJ_REMOVE);
	452	kobject_del(&bi->kobj);
3839e4b2	453	kobject_put(&bi->kobj);
0c032ab8	454	disk->integrity = NULL;
7ba1ba12 MP	455	}
7ba1ba12 MP	456	EXPORT_SYMBOL(blk_integrity_unregister);