litmus-rt.git - The LITMUS^RT kernel.

diff options

author	Brian Johnson <brijohn@gmail.com>	2009-09-02 12:14:41 -0400
committer	Mauro Carvalho Chehab <mchehab@redhat.com>	2009-09-12 11:20:13 -0400
commit	e8b7acc18045afd52c801e196e6a04aefc252795 (patch)
tree	41abacb6b499d9f55a8f0fcefd98c9b28c6d0bac /drivers/media/video/gspca/sn9c20x.c
parent	58aa68c2fbdc3d025a3aff280935ede66dbcdc3e (diff)

V4L/DVB (12705): gspca - sn9c20x: Add SXGA support to SOI968

Signed-off-by: Brian Johnson <brijohn@gmail.com> Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

Diffstat (limited to 'drivers/media/video/gspca/sn9c20x.c')

-rw-r--r--

drivers/media/video/gspca/sn9c20x.c

1 files changed, 20 insertions, 0 deletions


diff --git a/drivers/media/video/gspca/sn9c20x.c b/drivers/media/video/gspca/sn9c20x.c index 20b03a005293..e4a021ae9cca 100644 --- a/drivers/media/video/gspca/sn9c20x.c +++ b/drivers/media/video/gspca/sn9c20x.c
@@ -2007,6 +2007,7 @@ static int sd_config(struct gspca_dev *gspca_dev,
2007		2007
2008	switch (sd->sensor) {	2008	switch (sd->sensor) {
2009	case SENSOR_OV9650:	2009	case SENSOR_OV9650:
		2010	case SENSOR_SOI968:
2010	cam->cam_mode = sxga_mode;	2011	cam->cam_mode = sxga_mode;
2011	cam->nmodes = ARRAY_SIZE(sxga_mode);	2012	cam->nmodes = ARRAY_SIZE(sxga_mode);
2012	break;	2013	break;
@@ -2122,6 +2123,25 @@ static void configure_sensor_output(struct gspca_dev *gspca_dev, int mode)
2122	struct sd sd = (struct sd ) gspca_dev;	2123	struct sd sd = (struct sd ) gspca_dev;
2123	u8 value;	2124	u8 value;
2124	switch (sd->sensor) {	2125	switch (sd->sensor) {
		2126	case SENSOR_SOI968:
		2127	if (mode & MODE_SXGA) {
		2128	i2c_w1(gspca_dev, 0x17, 0x1d);
		2129	i2c_w1(gspca_dev, 0x18, 0xbd);
		2130	i2c_w1(gspca_dev, 0x19, 0x01);
		2131	i2c_w1(gspca_dev, 0x1a, 0x81);
		2132	i2c_w1(gspca_dev, 0x12, 0x00);
		2133	sd->hstart = 140;
		2134	sd->vstart = 19;
		2135	} else {
		2136	i2c_w1(gspca_dev, 0x17, 0x13);
		2137	i2c_w1(gspca_dev, 0x18, 0x63);
		2138	i2c_w1(gspca_dev, 0x19, 0x01);
		2139	i2c_w1(gspca_dev, 0x1a, 0x79);
		2140	i2c_w1(gspca_dev, 0x12, 0x40);
		2141	sd->hstart = 60;
		2142	sd->vstart = 11;
		2143	}
		2144	break;
2125	case SENSOR_OV9650:	2145	case SENSOR_OV9650:
2126	if (mode & MODE_SXGA) {	2146	if (mode & MODE_SXGA) {
2127	i2c_w1(gspca_dev, 0x17, 0x1b);	2147	i2c_w1(gspca_dev, 0x17, 0x1b);

446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511

512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584

/* * Copyright (C) 2011 STRATO. All rights reserved. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License v2 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; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 021110-1307, USA. */ #include <linux/blkdev.h> #include <linux/ratelimit.h> #include "ctree.h" #include "volumes.h" #include "disk-io.h" #include "ordered-data.h" #include "transaction.h" #include "backref.h" #include "extent_io.h" #include "check-integrity.h" #include "rcu-string.h" /* * This is only the first step towards a full-features scrub. It reads all * extent and super block and verifies the checksums. In case a bad checksum * is found or the extent cannot be read, good data will be written back if * any can be found. * * Future enhancements: * - In case an unrepairable extent is encountered, track which files are * affected and report them * - track and record media errors, throw out bad devices * - add a mode to also read unallocated space */ struct scrub_block; struct scrub_dev; #define SCRUB_PAGES_PER_BIO 16 /* 64k per bio */ #define SCRUB_BIOS_PER_DEV 16 /* 1 MB per device in flight */ #define SCRUB_MAX_PAGES_PER_BLOCK 16 /* 64k per node/leaf/sector */ struct scrub_page { struct scrub_block *sblock; struct page *page; struct btrfs_device *dev; u64 flags; /* extent flags */ u64 generation; u64 logical; u64 physical; struct { unsigned int mirror_num:8; unsigned int have_csum:1; unsigned int io_error:1; }; u8 csum[BTRFS_CSUM_SIZE]; }; struct scrub_bio { int index; struct scrub_dev *sdev; struct bio *bio; int err; u64 logical; u64 physical; struct scrub_page *pagev[SCRUB_PAGES_PER_BIO]; int page_count; int next_free; struct btrfs_work work; }; struct scrub_block { struct scrub_page pagev[SCRUB_MAX_PAGES_PER_BLOCK]; int page_count; atomic_t outstanding_pages; atomic_t ref_count; /* free mem on transition to zero */ struct scrub_dev *sdev; struct { unsigned int header_error:1; unsigned int checksum_error:1; unsigned int no_io_error_seen:1; unsigned int generation_error:1; /* also sets header_error */ }; }; struct scrub_dev { struct scrub_bio *bios[SCRUB_BIOS_PER_DEV]; struct btrfs_device *dev; int first_free; int curr; atomic_t in_flight; atomic_t fixup_cnt; spinlock_t list_lock; wait_queue_head_t list_wait; u16 csum_size; struct list_head csum_list; atomic_t cancel_req; int readonly; int pages_per_bio; /* <= SCRUB_PAGES_PER_BIO */ u32 sectorsize; u32 nodesize; u32 leafsize; /* * statistics */ struct btrfs_scrub_progress stat; spinlock_t stat_lock; }; struct scrub_fixup_nodatasum { struct scrub_dev *sdev; u64 logical; struct btrfs_root *root; struct btrfs_work work; int mirror_num; }; struct scrub_warning { struct btrfs_path *path; u64 extent_item_size; char *scratch_buf; char *msg_buf; const char *errstr; sector_t sector; u64 logical; struct btrfs_device *dev; int msg_bufsize; int scratch_bufsize; }; static int scrub_handle_errored_block(struct scrub_block *sblock_to_check); static int scrub_setup_recheck_block(struct scrub_dev *sdev, struct btrfs_mapping_tree *map_tree, u64 length, u64 logical, struct scrub_block *sblock); static int scrub_recheck_block(struct btrfs_fs_info *fs_info, struct scrub_block *sblock, int is_metadata, int have_csum, u8 *csum, u64 generation, u16 csum_size); static void scrub_recheck_block_checksum(struct btrfs_fs_info *fs_info, struct scrub_block *sblock, int is_metadata, int have_csum, const u8 *csum, u64 generation, u16 csum_size); static void scrub_complete_bio_end_io(struct bio *bio, int err); static int scrub_repair_block_from_good_copy(struct scrub_block *sblock_bad, struct scrub_block *sblock_good, int force_write); static int scrub_repair_page_from_good_copy(struct scrub_block *sblock_bad, struct scrub_block *sblock_good, int page_num, int force_write); static int scrub_checksum_data(struct scrub_block *sblock); static int scrub_checksum_tree_block(struct scrub_block *sblock); static int scrub_checksum_super(struct scrub_block *sblock); static void scrub_block_get(struct scrub_block *sblock); static void scrub_block_put(struct scrub_block *sblock); static int scrub_add_page_to_bio(struct scrub_dev *sdev, struct scrub_page *spage); static int scrub_pages(struct scrub_dev *sdev, u64 logical, u64 len, u64 physical, u64 flags, u64 gen, int mirror_num, u8 *csum, int force); static void scrub_bio_end_io(struct bio *bio, int err); static void scrub_bio_end_io_worker(struct btrfs_work *work); static void scrub_block_complete(struct scrub_block *sblock); static void scrub_free_csums(struct scrub_dev *sdev) { while (!list_empty(&sdev->csum_list)) { struct btrfs_ordered_sum *sum; sum = list_first_entry(&sdev->csum_list, struct btrfs_ordered_sum, list); list_del(&sum->list); kfree(sum); } } static noinline_for_stack void scrub_free_dev(struct scrub_dev *sdev) { int i; if (!sdev) return; /* this can happen when scrub is cancelled */ if (sdev->curr != -1) { struct scrub_bio *sbio = sdev->bios[sdev->curr]; for (i = 0; i < sbio->page_count; i++) { BUG_ON(!sbio->pagev[i]); BUG_ON(!sbio->pagev[i]->page); scrub_block_put(sbio->pagev[i]->sblock); } bio_put(sbio->bio); } for (i = 0; i < SCRUB_BIOS_PER_DEV; ++i) { struct scrub_bio *sbio = sdev->bios[i]; if (!sbio) break; kfree(sbio); } scrub_free_csums(sdev); kfree(sdev); } static noinline_for_stack struct scrub_dev *scrub_setup_dev(struct btrfs_device *dev) { struct scrub_dev *sdev; int i; struct btrfs_fs_info *fs_info = dev->dev_root->fs_info; int pages_per_bio; pages_per_bio = min_t(int, SCRUB_PAGES_PER_BIO, bio_get_nr_vecs(dev->bdev)); sdev = kzalloc(sizeof(*sdev), GFP_NOFS); if (!sdev) goto nomem; sdev->dev = dev; sdev->pages_per_bio = pages_per_bio; sdev->curr = -1; for (i = 0; i < SCRUB_BIOS_PER_DEV; ++i) { struct scrub_bio *sbio; sbio = kzalloc(sizeof(*sbio), GFP_NOFS); if (!sbio) goto nomem; sdev->bios[i] = sbio; sbio->index = i; sbio->sdev = sdev; sbio->page_count = 0; sbio->work.func = scrub_bio_end_io_worker; if (i != SCRUB_BIOS_PER_DEV-1) sdev->bios[i]->next_free = i + 1; else sdev->bios[i]->next_free = -1; } sdev->first_free = 0; sdev->nodesize = dev->dev_root->nodesize; sdev->leafsize = dev->dev_root->leafsize; sdev->sectorsize = dev->dev_root->sectorsize; atomic_set(&sdev->in_flight, 0); atomic_set(&sdev->fixup_cnt, 0); atomic_set(&sdev->cancel_req, 0); sdev->csum_size = btrfs_super_csum_size(fs_info->super_copy); INIT_LIST_HEAD(&sdev->csum_list); spin_lock_init(&sdev->list_lock); spin_lock_init(&sdev->stat_lock); init_waitqueue_head(&sdev->list_wait); return sdev; nomem: scrub_free_dev(sdev); return ERR_PTR(-ENOMEM); } static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root, void *ctx) { u64 isize; u32 nlink; int ret; int i; struct extent_buffer *eb; struct btrfs_inode_item *inode_item; struct scrub_warning *swarn = ctx; struct btrfs_fs_info *fs_info = swarn->dev->dev_root->fs_info; struct inode_fs_paths *ipath = NULL; struct btrfs_root *local_root; struct btrfs_key root_key; root_key.objectid = root; root_key.type = BTRFS_ROOT_ITEM_KEY; root_key.offset = (u64)-1; local_root = btrfs_read_fs_root_no_name(fs_info, &root_key); if (IS_ERR(local_root)) { ret = PTR_ERR(local_root); goto err; } ret = inode_item_info(inum, 0, local_root, swarn->path); if (ret) { btrfs_release_path(swarn->path); goto err; } eb = swarn->path->nodes[0]; inode_item = btrfs_item_ptr(eb, swarn->path->slots[0], struct btrfs_inode_item); isize = btrfs_inode_size(eb, inode_item); nlink = btrfs_inode_nlink(eb, inode_item); btrfs_release_path(swarn->path); ipath = init_ipath(4096, local_root, swarn->path); if (IS_ERR(ipath)) { ret = PTR_ERR(ipath); ipath = NULL; goto err; } ret = paths_from_inode(inum, ipath); if (ret < 0) goto err; /* * we deliberately ignore the bit ipath might have been too small to * hold all of the paths here */ for (i = 0; i < ipath->fspath->elem_cnt; ++i) printk_in_rcu(KERN_WARNING "btrfs: %s at logical %llu on dev " "%s, sector %llu, root %llu, inode %llu, offset %llu, " "length %llu, links %u (path: %s)\n", swarn->errstr, swarn->logical, rcu_str_deref(swarn->dev->name), (unsigned long long)swarn->sector, root, inum, offset, min(isize - offset, (u64)PAGE_SIZE), nlink, (char *)(unsigned long)ipath->fspath->val[i]); free_ipath(ipath); return 0; err: printk_in_rcu(KERN_WARNING "btrfs: %s at logical %llu on dev " "%s, sector %llu, root %llu, inode %llu, offset %llu: path " "resolving failed with ret=%d\n", swarn->errstr, swarn->logical, rcu_str_deref(swarn->dev->name), (unsigned long long)swarn->sector, root, inum, offset, ret); free_ipath(ipath); return 0; } static void scrub_print_warning(const char *errstr, struct scrub_block *sblock) { struct btrfs_device *dev = sblock->sdev->dev; struct btrfs_fs_info *fs_info = dev->dev_root->fs_info; struct btrfs_path *path; struct btrfs_key found_key; struct extent_buffer *eb; struct btrfs_extent_item *ei; struct scrub_warning swarn; u32 item_size; int ret; u64 ref_root; u8 ref_level; unsigned long ptr = 0; const int bufsize = 4096; u64 extent_item_pos; path = btrfs_alloc_path(); swarn.scratch_buf = kmalloc(bufsize, GFP_NOFS); swarn.msg_buf = kmalloc(bufsize, GFP_NOFS); BUG_ON(sblock->page_count < 1); swarn.sector = (sblock->pagev[0].physical) >> 9; swarn.logical = sblock->pagev[0].logical; swarn.errstr = errstr; swarn.dev = dev; swarn.msg_bufsize = bufsize; swarn.scratch_bufsize = bufsize; if (!path || !swarn.scratch_buf || !swarn.msg_buf) goto out; ret = extent_from_logical(fs_info, swarn.logical, path, &found_key); if (ret < 0) goto out; extent_item_pos = swarn.logical - found_key.objectid; swarn.extent_item_size = found_key.offset; eb = path->nodes[0]; ei = btrfs_item_ptr(eb, path->slots[0], struct btrfs_extent_item); item_size = btrfs_item_size_nr(eb, path->slots[0]); btrfs_release_path(path); if (ret & BTRFS_EXTENT_FLAG_TREE_BLOCK) { do { ret = tree_backref_for_extent(&ptr, eb, ei, item_size, &ref_root, &ref_level); printk_in_rcu(KERN_WARNING "btrfs: %s at logical %llu on dev %s, " "sector %llu: metadata %s (level %d) in tree " "%llu\n", errstr, swarn.logical, rcu_str_deref(dev->name), (unsigned long long)swarn.sector, ref_level ? "node" : "leaf", ret < 0 ? -1 : ref_level, ret < 0 ? -1 : ref_root); } while (ret != 1); } else { swarn.path = path; iterate_extent_inodes(fs_info, found_key.objectid, extent_item_pos, 1, scrub_print_warning_inode, &swarn); } out: btrfs_free_path(path); kfree(swarn.scratch_buf); kfree(swarn.msg_buf); } static int scrub_fixup_readpage(u64 inum, u64 offset, u64 root, void *ctx) { struct page *page = NULL; unsigned long index; struct scrub_fixup_nodatasum *fixup = ctx; int ret; int corrected = 0; struct btrfs_key key; struct inode *inode = NULL; u64 end = offset + PAGE_SIZE - 1; struct btrfs_root *local_root; key.objectid = root; key.type = BTRFS_ROOT_ITEM_KEY; key.offset = (u64)-1; local_root = btrfs_read_fs_root_no_name(fixup->root->fs_info, &key); if (IS_ERR(local_root)) return PTR_ERR(local_root); key.type = BTRFS_INODE_ITEM_KEY; key.objectid = inum; key.offset = 0; inode = btrfs_iget(fixup->root->fs_info->sb, &key, local_root, NULL); if (IS_ERR(inode)) return PTR_ERR(inode); index = offset >> PAGE_CACHE_SHIFT; page = find_or_create_page(inode->i_mapping, index, GFP_NOFS); if (!page) { ret = -ENOMEM; goto out; } if (PageUptodate(page)) { struct btrfs_mapping_tree *map_tree; if (PageDirty(page)) { /* * we need to write the data to the defect sector. the * data that was in that sector is not in memory, * because the page was modified. we must not write the * modified page to that sector. * * TODO: what could be done here: wait for the delalloc * runner to write out that page (might involve * COW) and see whether the sector is still * referenced afterwards. * * For the meantime, we'll treat this error * incorrectable, although there is a chance that a * later scrub will find the bad sector again and that * there's no dirty page in memory, then. */ ret = -EIO; goto out; } map_tree = &BTRFS_I(inode)->root->fs_info->mapping_tree; ret = repair_io_failure(map_tree, offset, PAGE_SIZE, fixup->logical, page, fixup->mirror_num); unlock_page(page); corrected = !ret; } else { /* * we need to get good data first. the general readpage path * will call repair_io_failure for us, we just have to make * sure we read the bad mirror. */ ret = set_extent_bits(&BTRFS_I(inode)->io_tree, offset, end, EXTENT_DAMAGED, GFP_NOFS); if (ret) { /* set_extent_bits should give proper error */ WARN_ON(ret > 0); if (ret > 0) ret = -EFAULT; goto out; } ret = extent_read_full_page(&BTRFS_I(inode)->io_tree, page, btrfs_get_extent, fixup->mirror_num); wait_on_page_locked(page); corrected = !test_range_bit(&BTRFS_I(inode)->io_tree, offset, end, EXTENT_DAMAGED, 0, NULL); if (!corrected) clear_extent_bits(&BTRFS_I(inode)->io_tree, offset, end, EXTENT_DAMAGED, GFP_NOFS); } out: if (page) put_page(page); if (inode) iput(inode); if (ret < 0) return ret; if (ret == 0 && corrected) { /* * we only need to call readpage for one of the inodes belonging * to this extent. so make iterate_extent_inodes stop */ return 1; } return -EIO; } static void scrub_fixup_nodatasum(struct btrfs_work *work) { int ret; struct scrub_fixup_nodatasum *fixup; struct scrub_dev *sdev; struct btrfs_trans_handle *trans = NULL; struct btrfs_fs_info *fs_info; struct btrfs_path *path; int uncorrectable = 0; fixup = container_of(work, struct scrub_fixup_nodatasum, work); sdev = fixup->sdev; fs_info = fixup->root->fs_info; path = btrfs_alloc_path(); if (!path) { spin_lock(&sdev->stat_lock); ++sdev->stat.malloc_errors; spin_unlock(&sdev->stat_lock); uncorrectable = 1; goto out; } trans = btrfs_join_transaction(fixup->root); if (IS_ERR(trans)) { uncorrectable = 1; goto out; } /* * the idea is to trigger a regular read through the standard path. we * read a page from the (failed) logical address by specifying the * corresponding copynum of the failed sector. thus, that readpage is * expected to fail. * that is the point where on-the-fly error correction will kick in * (once it's finished) and rewrite the failed sector if a good copy * can be found. */ ret = iterate_inodes_from_logical(fixup->logical, fixup->root->fs_info, path, scrub_fixup_readpage, fixup); if (ret < 0) { uncorrectable = 1; goto out; } WARN_ON(ret != 1); spin_lock(&sdev->stat_lock); ++sdev->stat.corrected_errors; spin_unlock(&sdev->stat_lock); out: if (trans && !IS_ERR(trans)) btrfs_end_transaction(trans, fixup->root); if (uncorrectable) { spin_lock(&sdev->stat_lock); ++sdev->stat.uncorrectable_errors; spin_unlock(&sdev->stat_lock); printk_ratelimited_in_rcu(KERN_ERR "btrfs: unable to fixup (nodatasum) error at logical %llu on dev %s\n", (unsigned long long)fixup->logical, rcu_str_deref(sdev->dev->name)); } btrfs_free_path(path); kfree(fixup); /* see caller why we're pretending to be paused in the scrub counters */ mutex_lock(&fs_info->scrub_lock); atomic_dec(&fs_info->scrubs_running); atomic_dec(&fs_info->scrubs_paused); mutex_unlock(&fs_info->scrub_lock); atomic_dec(&sdev->fixup_cnt); wake_up(&fs_info->scrub_pause_wait); wake_up(&sdev->list_wait); } /* * scrub_handle_errored_block gets called when either verification of the * pages failed or the bio failed to read, e.g. with EIO. In the latter * case, this function handles all pages in the bio, even though only one * may be bad. * The goal of this function is to repair the errored block by using the * contents of one of the mirrors. */ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check) { struct scrub_dev *sdev = sblock_to_check->sdev; struct btrfs_fs_info *fs_info; u64 length; u64 logical; u64 generation; unsigned int failed_mirror_index; unsigned int is_metadata; unsigned int have_csum; u8 *csum; struct scrub_block *sblocks_for_recheck; /* holds one for each mirror */ struct scrub_block *sblock_bad; int ret; int mirror_index; int page_num; int success; static DEFINE_RATELIMIT_STATE(_rs, DEFAULT_RATELIMIT_INTERVAL, DEFAULT_RATELIMIT_BURST); BUG_ON(sblock_to_check->page_count < 1); fs_info = sdev->dev->dev_root->fs_info; length = sblock_to_check->page_count * PAGE_SIZE; logical = sblock_to_check->pagev[0].logical; generation = sblock_to_check->pagev[0].generation; BUG_ON(sblock_to_check->pagev[0].mirror_num < 1); failed_mirror_index = sblock_to_check->pagev[0].mirror_num - 1; is_metadata = !(sblock_to_check->pagev[0].flags & BTRFS_EXTENT_FLAG_DATA); have_csum = sblock_to_check->pagev[0].have_csum; csum = sblock_to_check->pagev[0].csum; /* * read all mirrors one after the other. This includes to * re-read the extent or metadata block that failed (that was * the cause that this fixup code is called) another time, * page by page this time in order to know which pages * caused I/O errors and which ones are good (for all mirrors). * It is the goal to handle the situation when more than one * mirror contains I/O errors, but the errors do not * overlap, i.e. the data can be repaired by selecting the * pages from those mirrors without I/O error on the * particular pages. One example (with blocks >= 2 * PAGE_SIZE) * would be that mirror #1 has an I/O error on the first page, * the second page is good, and mirror #2 has an I/O error on * the second page, but the first page is good. * Then the first page of the first mirror can be repaired by * taking the first page of the second mirror, and the * second page of the second mirror can be repaired by * copying the contents of the 2nd page of the 1st mirror. * One more note: if the pages of one mirror contain I/O * errors, the checksum cannot be verified. In order to get * the best data for repairing, the first attempt is to find * a mirror without I/O errors and with a validated checksum. * Only if this is not possible, the pages are picked from * mirrors with I/O errors without considering the checksum. * If the latter is the case, at the end, the checksum of the * repaired area is verified in order to correctly maintain * the statistics. */ sblocks_for_recheck = kzalloc(BTRFS_MAX_MIRRORS * sizeof(*sblocks_for_recheck), GFP_NOFS); if (!sblocks_for_recheck) { spin_lock(&sdev->stat_lock); sdev->stat.malloc_errors++; sdev->stat.read_errors++; sdev->stat.uncorrectable_errors++; spin_unlock(&sdev->stat_lock); btrfs_dev_stat_inc_and_print(sdev->dev, BTRFS_DEV_STAT_READ_ERRS); goto out; } /* setup the context, map the logical blocks and alloc the pages */ ret = scrub_setup_recheck_block(sdev, &fs_info->mapping_tree, length, logical, sblocks_for_recheck); if (ret) { spin_lock(&sdev->stat_lock); sdev->stat.read_errors++; sdev->stat.uncorrectable_errors++; spin_unlock(&sdev->stat_lock); btrfs_dev_stat_inc_and_print(sdev->dev, BTRFS_DEV_STAT_READ_ERRS); goto out; } BUG_ON(failed_mirror_index >= BTRFS_MAX_MIRRORS); sblock_bad = sblocks_for_recheck + failed_mirror_index; /* build and submit the bios for the failed mirror, check checksums */ ret = scrub_recheck_block(fs_info, sblock_bad, is_metadata, have_csum, csum, generation, sdev->csum_size); if (ret) { spin_lock(&sdev->stat_lock); sdev->stat.read_errors++; sdev->stat.uncorrectable_errors++; spin_unlock(&sdev->stat_lock); btrfs_dev_stat_inc_and_print(sdev->dev, BTRFS_DEV_STAT_READ_ERRS); goto out; } if (!sblock_bad->header_error && !sblock_bad->checksum_error && sblock_bad->no_io_error_seen) { /* * the error disappeared after reading page by page, or * the area was part of a huge bio and other parts of the * bio caused I/O errors, or the block layer merged several * read requests into one and the error is caused by a * different bio (usually one of the two latter cases is * the cause) */ spin_lock(&sdev->stat_lock); sdev->stat.unverified_errors++; spin_unlock(&sdev->stat_lock); goto out; } if (!sblock_bad->no_io_error_seen) { spin_lock(&sdev->stat_lock); sdev->stat.read_errors++; spin_unlock(&sdev->stat_lock); if (__ratelimit(&_rs)) 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) { spin_lock(&sdev->stat_lock); sdev->stat.csum_errors++; spin_unlock(&sdev->stat_lock); if (__ratelimit(&_rs)) 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) { spin_lock(&sdev->stat_lock); sdev->stat.verify_errors++; spin_unlock(&sdev->stat_lock); if (__ratelimit(&_rs)) scrub_print_warning("checksum/header error", 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) goto did_not_correct_error; if (!is_metadata && !have_csum) { struct scrub_fixup_nodatasum *fixup_nodatasum; /* * !is_metadata and !have_csum, this means that the data * might not be COW'ed, that it might be modified * concurrently. The general strategy to work on the * commit root does not help in the case when COW is not * used. */ fixup_nodatasum = kzalloc(sizeof(*fixup_nodatasum), GFP_NOFS); if (!fixup_nodatasum) goto did_not_correct_error; fixup_nodatasum->sdev = sdev; fixup_nodatasum->logical = logical; fixup_nodatasum->root = fs_info->extent_root;


context:
space:
mode: