Btrfs: add device counters for detected IO and checksum errors (442a4f63) · Commits · e / devices / android_kernel_samsung_universal8895

fs/btrfs/disk-io.c

+9 −4

Original line number	Original line	Diff line number	Diff line
	@@ -2557,18 +2557,19 @@ recovery_tree_root:

	static void btrfs_end_buffer_write_sync(struct buffer_head *bh, int uptodate)		static void btrfs_end_buffer_write_sync(struct buffer_head *bh, int uptodate)
	{		{
	char b[BDEVNAME_SIZE];

	if (uptodate) {		if (uptodate) {
	set_buffer_uptodate(bh);		set_buffer_uptodate(bh);
	} else {		} else {
			struct btrfs_device device = (struct btrfs_device )
			bh->b_private;

	printk_ratelimited(KERN_WARNING "lost page write due to "		printk_ratelimited(KERN_WARNING "lost page write due to "
	"I/O error on %s\n",		"I/O error on %s\n", device->name);
	bdevname(bh->b_bdev, b));
	/* note, we dont' set_buffer_write_io_error because we have		/* note, we dont' set_buffer_write_io_error because we have
	* our own ways of dealing with the IO errors		* our own ways of dealing with the IO errors
	*/		*/
	clear_buffer_uptodate(bh);		clear_buffer_uptodate(bh);
			btrfs_dev_stat_inc_and_print(device, BTRFS_DEV_STAT_WRITE_ERRS);
	}		}
	unlock_buffer(bh);		unlock_buffer(bh);
	put_bh(bh);		put_bh(bh);
	@@ -2683,6 +2684,7 @@ static int write_dev_supers(struct btrfs_device *device,
	set_buffer_uptodate(bh);		set_buffer_uptodate(bh);
	lock_buffer(bh);		lock_buffer(bh);
	bh->b_end_io = btrfs_end_buffer_write_sync;		bh->b_end_io = btrfs_end_buffer_write_sync;
			bh->b_private = device;
	}		}

	/*		/*
	@@ -2741,6 +2743,9 @@ static int write_dev_flush(struct btrfs_device *device, int wait)
	}		}
	if (!bio_flagged(bio, BIO_UPTODATE)) {		if (!bio_flagged(bio, BIO_UPTODATE)) {
	ret = -EIO;		ret = -EIO;
			if (!bio_flagged(bio, BIO_EOPNOTSUPP))
			btrfs_dev_stat_inc_and_print(device,
			BTRFS_DEV_STAT_FLUSH_ERRS);
	}		}

	/* drop the reference from the wait == 0 run */		/* drop the reference from the wait == 0 run */

fs/btrfs/extent_io.c

+16 −2

Original line number	Original line	Diff line number	Diff line
	@@ -1913,6 +1913,7 @@ int repair_io_failure(struct btrfs_mapping_tree *map_tree, u64 start,
	if (!test_bit(BIO_UPTODATE, &bio->bi_flags)) {		if (!test_bit(BIO_UPTODATE, &bio->bi_flags)) {
	/* try to remap that extent elsewhere? */		/* try to remap that extent elsewhere? */
	bio_put(bio);		bio_put(bio);
			btrfs_dev_stat_inc_and_print(dev, BTRFS_DEV_STAT_WRITE_ERRS);
	return -EIO;		return -EIO;
	}		}

	@@ -2327,11 +2328,24 @@ static void end_bio_extent_readpage(struct bio *bio, int err)
	if (uptodate && tree->ops && tree->ops->readpage_end_io_hook) {		if (uptodate && tree->ops && tree->ops->readpage_end_io_hook) {
	ret = tree->ops->readpage_end_io_hook(page, start, end,		ret = tree->ops->readpage_end_io_hook(page, start, end,
	state, mirror);		state, mirror);
	if (ret)		if (ret) {
			/* no IO indicated but software detected errors
			* in the block, either checksum errors or
			* issues with the contents */
			struct btrfs_root *root =
			BTRFS_I(page->mapping->host)->root;
			struct btrfs_device *device;

	uptodate = 0;		uptodate = 0;
	else		device = btrfs_find_device_for_logical(
			root, start, mirror);
			if (device)
			btrfs_dev_stat_inc_and_print(device,
			BTRFS_DEV_STAT_CORRUPTION_ERRS);
			} else {
	clean_io_failure(start, page);		clean_io_failure(start, page);
	}		}
			}

	if (!uptodate && tree->ops && tree->ops->readpage_io_failed_hook) {		if (!uptodate && tree->ops && tree->ops->readpage_io_failed_hook) {
	ret = tree->ops->readpage_io_failed_hook(page, mirror);		ret = tree->ops->readpage_io_failed_hook(page, mirror);

fs/btrfs/ioctl.h

+19 −0

Original line number	Original line	Diff line number	Diff line
	@@ -266,6 +266,25 @@ struct btrfs_ioctl_logical_ino_args {
	__u64 inodes;		__u64 inodes;
	};		};

			enum btrfs_dev_stat_values {
			/* disk I/O failure stats */
			BTRFS_DEV_STAT_WRITE_ERRS, /* EIO or EREMOTEIO from lower layers */
			BTRFS_DEV_STAT_READ_ERRS, /* EIO or EREMOTEIO from lower layers */
			BTRFS_DEV_STAT_FLUSH_ERRS, /* EIO or EREMOTEIO from lower layers */

			/* stats for indirect indications for I/O failures */
			BTRFS_DEV_STAT_CORRUPTION_ERRS, /* checksum error, bytenr error or
			* contents is illegal: this is an
			* indication that the block was damaged
			* during read or write, or written to
			* wrong location or read from wrong
			* location */
			BTRFS_DEV_STAT_GENERATION_ERRS, /* an indication that blocks have not
			* been written */

			BTRFS_DEV_STAT_VALUES_MAX
			};

	#define BTRFS_IOC_SNAP_CREATE _IOW(BTRFS_IOCTL_MAGIC, 1, \		#define BTRFS_IOC_SNAP_CREATE _IOW(BTRFS_IOCTL_MAGIC, 1, \
	struct btrfs_ioctl_vol_args)		struct btrfs_ioctl_vol_args)
	#define BTRFS_IOC_DEFRAG _IOW(BTRFS_IOCTL_MAGIC, 2, \		#define BTRFS_IOC_DEFRAG _IOW(BTRFS_IOCTL_MAGIC, 2, \

fs/btrfs/scrub.c

+49 −16

Original line number	Original line	Diff line number	Diff line
	@@ -50,7 +50,7 @@ struct scrub_dev;
	struct scrub_page {		struct scrub_page {
	struct scrub_block *sblock;		struct scrub_block *sblock;
	struct page *page;		struct page *page;
	struct block_device *bdev;		struct btrfs_device *dev;
	u64 flags; /* extent flags */		u64 flags; /* extent flags */
	u64 generation;		u64 generation;
	u64 logical;		u64 logical;
	@@ -86,6 +86,7 @@ struct scrub_block {
	unsigned int header_error:1;		unsigned int header_error:1;
	unsigned int checksum_error:1;		unsigned int checksum_error:1;
	unsigned int no_io_error_seen:1;		unsigned int no_io_error_seen:1;
			unsigned int generation_error:1; /* also sets header_error */
	};		};
	};		};

	@@ -675,6 +676,8 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
	sdev->stat.read_errors++;		sdev->stat.read_errors++;
	sdev->stat.uncorrectable_errors++;		sdev->stat.uncorrectable_errors++;
	spin_unlock(&sdev->stat_lock);		spin_unlock(&sdev->stat_lock);
			btrfs_dev_stat_inc_and_print(sdev->dev,
			BTRFS_DEV_STAT_READ_ERRS);
	goto out;		goto out;
	}		}

	@@ -686,6 +689,8 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
	sdev->stat.read_errors++;		sdev->stat.read_errors++;
	sdev->stat.uncorrectable_errors++;		sdev->stat.uncorrectable_errors++;
	spin_unlock(&sdev->stat_lock);		spin_unlock(&sdev->stat_lock);
			btrfs_dev_stat_inc_and_print(sdev->dev,
			BTRFS_DEV_STAT_READ_ERRS);
	goto out;		goto out;
	}		}
	BUG_ON(failed_mirror_index >= BTRFS_MAX_MIRRORS);		BUG_ON(failed_mirror_index >= BTRFS_MAX_MIRRORS);
	@@ -699,6 +704,8 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
	sdev->stat.read_errors++;		sdev->stat.read_errors++;
	sdev->stat.uncorrectable_errors++;		sdev->stat.uncorrectable_errors++;
	spin_unlock(&sdev->stat_lock);		spin_unlock(&sdev->stat_lock);
			btrfs_dev_stat_inc_and_print(sdev->dev,
			BTRFS_DEV_STAT_READ_ERRS);
	goto out;		goto out;
	}		}

	@@ -725,12 +732,16 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
	spin_unlock(&sdev->stat_lock);		spin_unlock(&sdev->stat_lock);
	if (__ratelimit(&_rs))		if (__ratelimit(&_rs))
	scrub_print_warning("i/o error", sblock_to_check);		scrub_print_warning("i/o error", sblock_to_check);
			btrfs_dev_stat_inc_and_print(sdev->dev,
			BTRFS_DEV_STAT_READ_ERRS);
	} else if (sblock_bad->checksum_error) {		} else if (sblock_bad->checksum_error) {
	spin_lock(&sdev->stat_lock);		spin_lock(&sdev->stat_lock);
	sdev->stat.csum_errors++;		sdev->stat.csum_errors++;
	spin_unlock(&sdev->stat_lock);		spin_unlock(&sdev->stat_lock);
	if (__ratelimit(&_rs))		if (__ratelimit(&_rs))
	scrub_print_warning("checksum error", sblock_to_check);		scrub_print_warning("checksum error", sblock_to_check);
			btrfs_dev_stat_inc_and_print(sdev->dev,
			BTRFS_DEV_STAT_CORRUPTION_ERRS);
	} else if (sblock_bad->header_error) {		} else if (sblock_bad->header_error) {
	spin_lock(&sdev->stat_lock);		spin_lock(&sdev->stat_lock);
	sdev->stat.verify_errors++;		sdev->stat.verify_errors++;
	@@ -738,6 +749,12 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
	if (__ratelimit(&_rs))		if (__ratelimit(&_rs))
	scrub_print_warning("checksum/header error",		scrub_print_warning("checksum/header error",
	sblock_to_check);		sblock_to_check);
			if (sblock_bad->generation_error)
			btrfs_dev_stat_inc_and_print(sdev->dev,
			BTRFS_DEV_STAT_GENERATION_ERRS);
			else
			btrfs_dev_stat_inc_and_print(sdev->dev,
			BTRFS_DEV_STAT_CORRUPTION_ERRS);
	}		}

	if (sdev->readonly)		if (sdev->readonly)
	@@ -998,8 +1015,8 @@ static int scrub_setup_recheck_block(struct scrub_dev *sdev,
	page = sblock->pagev + page_index;		page = sblock->pagev + page_index;
	page->logical = logical;		page->logical = logical;
	page->physical = bbio->stripes[mirror_index].physical;		page->physical = bbio->stripes[mirror_index].physical;
	/* for missing devices, bdev is NULL */		/* for missing devices, dev->bdev is NULL */
	page->bdev = bbio->stripes[mirror_index].dev->bdev;		page->dev = bbio->stripes[mirror_index].dev;
	page->mirror_num = mirror_index + 1;		page->mirror_num = mirror_index + 1;
	page->page = alloc_page(GFP_NOFS);		page->page = alloc_page(GFP_NOFS);
	if (!page->page) {		if (!page->page) {
	@@ -1043,7 +1060,7 @@ static int scrub_recheck_block(struct btrfs_fs_info *fs_info,
	struct scrub_page *page = sblock->pagev + page_num;		struct scrub_page *page = sblock->pagev + page_num;
	DECLARE_COMPLETION_ONSTACK(complete);		DECLARE_COMPLETION_ONSTACK(complete);

	if (page->bdev == NULL) {		if (page->dev->bdev == NULL) {
	page->io_error = 1;		page->io_error = 1;
	sblock->no_io_error_seen = 0;		sblock->no_io_error_seen = 0;
	continue;		continue;
	@@ -1053,7 +1070,7 @@ static int scrub_recheck_block(struct btrfs_fs_info *fs_info,
	bio = bio_alloc(GFP_NOFS, 1);		bio = bio_alloc(GFP_NOFS, 1);
	if (!bio)		if (!bio)
	return -EIO;		return -EIO;
	bio->bi_bdev = page->bdev;		bio->bi_bdev = page->dev->bdev;
	bio->bi_sector = page->physical >> 9;		bio->bi_sector = page->physical >> 9;
	bio->bi_end_io = scrub_complete_bio_end_io;		bio->bi_end_io = scrub_complete_bio_end_io;
	bio->bi_private = &complete;		bio->bi_private = &complete;
	@@ -1102,11 +1119,14 @@ static void scrub_recheck_block_checksum(struct btrfs_fs_info *fs_info,
	h = (struct btrfs_header *)mapped_buffer;		h = (struct btrfs_header *)mapped_buffer;

	if (sblock->pagev[0].logical != le64_to_cpu(h->bytenr) \|\|		if (sblock->pagev[0].logical != le64_to_cpu(h->bytenr) \|\|
	generation != le64_to_cpu(h->generation) \|\|
	memcmp(h->fsid, fs_info->fsid, BTRFS_UUID_SIZE) \|\|		memcmp(h->fsid, fs_info->fsid, BTRFS_UUID_SIZE) \|\|
	memcmp(h->chunk_tree_uuid, fs_info->chunk_tree_uuid,		memcmp(h->chunk_tree_uuid, fs_info->chunk_tree_uuid,
	BTRFS_UUID_SIZE))		BTRFS_UUID_SIZE)) {
			sblock->header_error = 1;
			} else if (generation != le64_to_cpu(h->generation)) {
	sblock->header_error = 1;		sblock->header_error = 1;
			sblock->generation_error = 1;
			}
	csum = h->csum;		csum = h->csum;
	} else {		} else {
	if (!have_csum)		if (!have_csum)
	@@ -1182,7 +1202,7 @@ static int scrub_repair_page_from_good_copy(struct scrub_block *sblock_bad,
	bio = bio_alloc(GFP_NOFS, 1);		bio = bio_alloc(GFP_NOFS, 1);
	if (!bio)		if (!bio)
	return -EIO;		return -EIO;
	bio->bi_bdev = page_bad->bdev;		bio->bi_bdev = page_bad->dev->bdev;
	bio->bi_sector = page_bad->physical >> 9;		bio->bi_sector = page_bad->physical >> 9;
	bio->bi_end_io = scrub_complete_bio_end_io;		bio->bi_end_io = scrub_complete_bio_end_io;
	bio->bi_private = &complete;		bio->bi_private = &complete;
	@@ -1196,6 +1216,12 @@ static int scrub_repair_page_from_good_copy(struct scrub_block *sblock_bad,

	/* this will also unplug the queue */		/* this will also unplug the queue */
	wait_for_completion(&complete);		wait_for_completion(&complete);
			if (!bio_flagged(bio, BIO_UPTODATE)) {
			btrfs_dev_stat_inc_and_print(page_bad->dev,
			BTRFS_DEV_STAT_WRITE_ERRS);
			bio_put(bio);
			return -EIO;
			}
	bio_put(bio);		bio_put(bio);
	}		}

	@@ -1352,7 +1378,8 @@ static int scrub_checksum_super(struct scrub_block *sblock)
	u64 mapped_size;		u64 mapped_size;
	void *p;		void *p;
	u32 crc = ~(u32)0;		u32 crc = ~(u32)0;
	int fail = 0;		int fail_gen = 0;
			int fail_cor = 0;
	u64 len;		u64 len;
	int index;		int index;

	@@ -1363,13 +1390,13 @@ static int scrub_checksum_super(struct scrub_block *sblock)
	memcpy(on_disk_csum, s->csum, sdev->csum_size);		memcpy(on_disk_csum, s->csum, sdev->csum_size);

	if (sblock->pagev[0].logical != le64_to_cpu(s->bytenr))		if (sblock->pagev[0].logical != le64_to_cpu(s->bytenr))
	++fail;		++fail_cor;

	if (sblock->pagev[0].generation != le64_to_cpu(s->generation))		if (sblock->pagev[0].generation != le64_to_cpu(s->generation))
	++fail;		++fail_gen;

	if (memcmp(s->fsid, fs_info->fsid, BTRFS_UUID_SIZE))		if (memcmp(s->fsid, fs_info->fsid, BTRFS_UUID_SIZE))
	++fail;		++fail_cor;

	len = BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE;		len = BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE;
	mapped_size = PAGE_SIZE - BTRFS_CSUM_SIZE;		mapped_size = PAGE_SIZE - BTRFS_CSUM_SIZE;
	@@ -1394,9 +1421,9 @@ static int scrub_checksum_super(struct scrub_block *sblock)

	btrfs_csum_final(crc, calculated_csum);		btrfs_csum_final(crc, calculated_csum);
	if (memcmp(calculated_csum, on_disk_csum, sdev->csum_size))		if (memcmp(calculated_csum, on_disk_csum, sdev->csum_size))
	++fail;		++fail_cor;

	if (fail) {		if (fail_cor + fail_gen) {
	/*		/*
	* if we find an error in a super block, we just report it.		* if we find an error in a super block, we just report it.
	* They will get written with the next transaction commit		* They will get written with the next transaction commit
	@@ -1405,9 +1432,15 @@ static int scrub_checksum_super(struct scrub_block *sblock)
	spin_lock(&sdev->stat_lock);		spin_lock(&sdev->stat_lock);
	++sdev->stat.super_errors;		++sdev->stat.super_errors;
	spin_unlock(&sdev->stat_lock);		spin_unlock(&sdev->stat_lock);
			if (fail_cor)
			btrfs_dev_stat_inc_and_print(sdev->dev,
			BTRFS_DEV_STAT_CORRUPTION_ERRS);
			else
			btrfs_dev_stat_inc_and_print(sdev->dev,
			BTRFS_DEV_STAT_GENERATION_ERRS);
	}		}

	return fail;		return fail_cor + fail_gen;
	}		}

	static void scrub_block_get(struct scrub_block *sblock)		static void scrub_block_get(struct scrub_block *sblock)
	@@ -1551,7 +1584,7 @@ static int scrub_pages(struct scrub_dev *sdev, u64 logical, u64 len,
	return -ENOMEM;		return -ENOMEM;
	}		}
	spage->sblock = sblock;		spage->sblock = sblock;
	spage->bdev = sdev->dev->bdev;		spage->dev = sdev->dev;
	spage->flags = flags;		spage->flags = flags;
	spage->generation = gen;		spage->generation = gen;
	spage->logical = logical;		spage->logical = logical;

fs/btrfs/volumes.c

+92 −2

Original line number	Original line	Diff line number	Diff line
	@@ -23,6 +23,7 @@
	#include <linux/random.h>		#include <linux/random.h>
	#include <linux/iocontext.h>		#include <linux/iocontext.h>
	#include <linux/capability.h>		#include <linux/capability.h>
			#include <linux/ratelimit.h>
	#include <linux/kthread.h>		#include <linux/kthread.h>
	#include <asm/div64.h>		#include <asm/div64.h>
	#include "compat.h"		#include "compat.h"
	@@ -4001,13 +4002,58 @@ int btrfs_rmap_block(struct btrfs_mapping_tree *map_tree,
	return 0;		return 0;
	}		}

			static void merge_stripe_index_into_bio_private(void bi_private,
			unsigned int stripe_index)
			{
			/*
			* with single, dup, RAID0, RAID1 and RAID10, stripe_index is
			* at most 1.
			* The alternative solution (instead of stealing bits from the
			* pointer) would be to allocate an intermediate structure
			* that contains the old private pointer plus the stripe_index.
			*/
			BUG_ON((((uintptr_t)bi_private) & 3) != 0);
			BUG_ON(stripe_index > 3);
			return (void *)(((uintptr_t)bi_private) \| stripe_index);
			}

			static struct btrfs_bio extract_bbio_from_bio_private(void bi_private)
			{
			return (struct btrfs_bio *)(((uintptr_t)bi_private) & ~((uintptr_t)3));
			}

			static unsigned int extract_stripe_index_from_bio_private(void *bi_private)
			{
			return (unsigned int)((uintptr_t)bi_private) & 3;
			}

	static void btrfs_end_bio(struct bio *bio, int err)		static void btrfs_end_bio(struct bio *bio, int err)
	{		{
	struct btrfs_bio *bbio = bio->bi_private;		struct btrfs_bio *bbio = extract_bbio_from_bio_private(bio->bi_private);
	int is_orig_bio = 0;		int is_orig_bio = 0;

	if (err)		if (err) {
	atomic_inc(&bbio->error);		atomic_inc(&bbio->error);
			if (err == -EIO \|\| err == -EREMOTEIO) {
			unsigned int stripe_index =
			extract_stripe_index_from_bio_private(
			bio->bi_private);
			struct btrfs_device *dev;

			BUG_ON(stripe_index >= bbio->num_stripes);
			dev = bbio->stripes[stripe_index].dev;
			if (bio->bi_rw & WRITE)
			btrfs_dev_stat_inc(dev,
			BTRFS_DEV_STAT_WRITE_ERRS);
			else
			btrfs_dev_stat_inc(dev,
			BTRFS_DEV_STAT_READ_ERRS);
			if ((bio->bi_rw & WRITE_FLUSH) == WRITE_FLUSH)
			btrfs_dev_stat_inc(dev,
			BTRFS_DEV_STAT_FLUSH_ERRS);
			btrfs_dev_stat_print_on_error(dev);
			}
			}

	if (bio == bbio->orig_bio)		if (bio == bbio->orig_bio)
	is_orig_bio = 1;		is_orig_bio = 1;
	@@ -4149,6 +4195,8 @@ int btrfs_map_bio(struct btrfs_root root, int rw, struct bio bio,
	bio = first_bio;		bio = first_bio;
	}		}
	bio->bi_private = bbio;		bio->bi_private = bbio;
			bio->bi_private = merge_stripe_index_into_bio_private(
			bio->bi_private, (unsigned int)dev_nr);
	bio->bi_end_io = btrfs_end_bio;		bio->bi_end_io = btrfs_end_bio;
	bio->bi_sector = bbio->stripes[dev_nr].physical >> 9;		bio->bi_sector = bbio->stripes[dev_nr].physical >> 9;
	dev = bbio->stripes[dev_nr].dev;		dev = bbio->stripes[dev_nr].dev;
	@@ -4509,6 +4557,28 @@ int btrfs_read_sys_array(struct btrfs_root *root)
	return ret;		return ret;
	}		}

			struct btrfs_device btrfs_find_device_for_logical(struct btrfs_root root,
			u64 logical, int mirror_num)
			{
			struct btrfs_mapping_tree *map_tree = &root->fs_info->mapping_tree;
			int ret;
			u64 map_length = 0;
			struct btrfs_bio *bbio = NULL;
			struct btrfs_device *device;

			BUG_ON(mirror_num == 0);
			ret = btrfs_map_block(map_tree, WRITE, logical, &map_length, &bbio,
			mirror_num);
			if (ret) {
			BUG_ON(bbio != NULL);
			return NULL;
			}
			BUG_ON(mirror_num != bbio->mirror_num);
			device = bbio->stripes[mirror_num - 1].dev;
			kfree(bbio);
			return device;
			}

	int btrfs_read_chunk_tree(struct btrfs_root *root)		int btrfs_read_chunk_tree(struct btrfs_root *root)
	{		{
	struct btrfs_path *path;		struct btrfs_path *path;
	@@ -4583,3 +4653,23 @@ error:
	btrfs_free_path(path);		btrfs_free_path(path);
	return ret;		return ret;
	}		}

			void btrfs_dev_stat_inc_and_print(struct btrfs_device *dev, int index)
			{
			btrfs_dev_stat_inc(dev, index);
			btrfs_dev_stat_print_on_error(dev);
			}

			void btrfs_dev_stat_print_on_error(struct btrfs_device *dev)
			{
			printk_ratelimited(KERN_ERR
			"btrfs: bdev %s errs: wr %u, rd %u, flush %u, corrupt %u, gen %u\n",
			dev->name,
			btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_WRITE_ERRS),
			btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_READ_ERRS),
			btrfs_dev_stat_read(dev, BTRFS_DEV_STAT_FLUSH_ERRS),
			btrfs_dev_stat_read(dev,
			BTRFS_DEV_STAT_CORRUPTION_ERRS),
			btrfs_dev_stat_read(dev,
			BTRFS_DEV_STAT_GENERATION_ERRS));
			}