| 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
| ||
|
Message-ID: <202011111913.B2a3mcth-lkp@intel.com>
Date: Wed, 11 Nov 2020 19:08:15 +0800
From: kernel test robot <lkp@...el.com>
To: Xiao Ni <xni@...hat.com>
Cc: kbuild-all@...ts.01.org, linux-kernel@...r.kernel.org,
Song Liu <songliubraving@...com>
Subject: drivers/md/raid10.c:1698:39: warning: Uninitialized variable:
first_r10bio
tree: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git master
head: eccc876724927ff3b9ff91f36f7b6b159e948f0c
commit: d3ee2d8415a6256c1c41e1be36e80e640c3e6359 md/raid10: improve discard request for far layout
date: 7 weeks ago
compiler: sparc64-linux-gcc (GCC) 9.3.0
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@...el.com>
"cppcheck warnings: (new ones prefixed by >>)"
In file included from drivers/md/raid10.c:
>> drivers/md/raid10.c:1698:39: warning: Uninitialized variable: first_r10bio [uninitvar]
r10_bio->master_bio = (struct bio *)first_r10bio;
^
cppcheck possible warnings: (new ones prefixed by >>, may not real problems)
In file included from drivers/md/raid10.c:
drivers/md/md.h:622:9: warning: Identical condition 'sd', second condition is always false [identicalConditionAfterEarlyExit]
return sd;
^
drivers/md/md.h:620:6: note: first condition
if (sd)
^
drivers/md/md.h:622:9: note: second condition
return sd;
^
drivers/md/raid10.c:3504:5: warning: Either the condition 'bio' is redundant or there is possible null pointer dereference: bio. [nullPointerRedundantCheck]
bio->bi_next = biolist;
^
drivers/md/raid10.c:3496:9: note: Assuming that condition 'bio' is not redundant
if (bio)
^
drivers/md/raid10.c:3504:5: note: Null pointer dereference
bio->bi_next = biolist;
^
drivers/md/raid10.c:3506:5: warning: Either the condition 'bio' is redundant or there is possible null pointer dereference: bio. [nullPointerRedundantCheck]
bio->bi_end_io = end_sync_write;
^
drivers/md/raid10.c:3496:9: note: Assuming that condition 'bio' is not redundant
if (bio)
^
drivers/md/raid10.c:3506:5: note: Null pointer dereference
bio->bi_end_io = end_sync_write;
^
vim +1698 drivers/md/raid10.c
1588
1589 /* There are some limitations to handle discard bio
1590 * 1st, the discard size is bigger than stripe_size*2.
1591 * 2st, if the discard bio spans reshape progress, we use the old way to
1592 * handle discard bio
1593 */
1594 static int raid10_handle_discard(struct mddev *mddev, struct bio *bio)
1595 {
1596 struct r10conf *conf = mddev->private;
1597 struct geom *geo = &conf->geo;
1598 struct r10bio *r10_bio, *first_r10bio;
1599 int far_copies = geo->far_copies;
1600 bool first_copy = true;
1601
1602 int disk;
1603 sector_t chunk;
1604 unsigned int stripe_size;
1605 sector_t split_size;
1606
1607 sector_t bio_start, bio_end;
1608 sector_t first_stripe_index, last_stripe_index;
1609 sector_t start_disk_offset;
1610 unsigned int start_disk_index;
1611 sector_t end_disk_offset;
1612 unsigned int end_disk_index;
1613 unsigned int remainder;
1614
1615 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
1616 return -EAGAIN;
1617
1618 wait_barrier(conf);
1619
1620 /* Check reshape again to avoid reshape happens after checking
1621 * MD_RECOVERY_RESHAPE and before wait_barrier
1622 */
1623 if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
1624 goto out;
1625
1626 stripe_size = geo->raid_disks << geo->chunk_shift;
1627 bio_start = bio->bi_iter.bi_sector;
1628 bio_end = bio_end_sector(bio);
1629
1630 /* Maybe one discard bio is smaller than strip size or across one stripe
1631 * and discard region is larger than one stripe size. For far offset layout,
1632 * if the discard region is not aligned with stripe size, there is hole
1633 * when we submit discard bio to member disk. For simplicity, we only
1634 * handle discard bio which discard region is bigger than stripe_size*2
1635 */
1636 if (bio_sectors(bio) < stripe_size*2)
1637 goto out;
1638
1639 /* For far and far offset layout, if bio is not aligned with stripe size,
1640 * it splits the part that is not aligned with strip size.
1641 */
1642 div_u64_rem(bio_start, stripe_size, &remainder);
1643 if ((far_copies > 1) && remainder) {
1644 split_size = stripe_size - remainder;
1645 bio = raid10_split_bio(conf, bio, split_size, false);
1646 }
1647 div_u64_rem(bio_end, stripe_size, &remainder);
1648 if ((far_copies > 1) && remainder) {
1649 split_size = bio_sectors(bio) - remainder;
1650 bio = raid10_split_bio(conf, bio, split_size, true);
1651 }
1652
1653 bio_start = bio->bi_iter.bi_sector;
1654 bio_end = bio_end_sector(bio);
1655
1656 /* raid10 uses chunk as the unit to store data. It's similar like raid0.
1657 * One stripe contains the chunks from all member disk (one chunk from
1658 * one disk at the same HBA address). For layout detail, see 'man md 4'
1659 */
1660 chunk = bio_start >> geo->chunk_shift;
1661 chunk *= geo->near_copies;
1662 first_stripe_index = chunk;
1663 start_disk_index = sector_div(first_stripe_index, geo->raid_disks);
1664 if (geo->far_offset)
1665 first_stripe_index *= geo->far_copies;
1666 start_disk_offset = (bio_start & geo->chunk_mask) +
1667 (first_stripe_index << geo->chunk_shift);
1668
1669 chunk = bio_end >> geo->chunk_shift;
1670 chunk *= geo->near_copies;
1671 last_stripe_index = chunk;
1672 end_disk_index = sector_div(last_stripe_index, geo->raid_disks);
1673 if (geo->far_offset)
1674 last_stripe_index *= geo->far_copies;
1675 end_disk_offset = (bio_end & geo->chunk_mask) +
1676 (last_stripe_index << geo->chunk_shift);
1677
1678 retry_discard:
1679 r10_bio = mempool_alloc(&conf->r10bio_pool, GFP_NOIO);
1680 r10_bio->mddev = mddev;
1681 r10_bio->state = 0;
1682 r10_bio->sectors = 0;
1683 memset(r10_bio->devs, 0, sizeof(r10_bio->devs[0]) * geo->raid_disks);
1684 wait_blocked_dev(mddev, r10_bio);
1685
1686 /* For far layout it needs more than one r10bio to cover all regions.
1687 * Inspired by raid10_sync_request, we can use the first r10bio->master_bio
1688 * to record the discard bio. Other r10bio->master_bio record the first
1689 * r10bio. The first r10bio only release after all other r10bios finish.
1690 * The discard bio returns only first r10bio finishes
1691 */
1692 if (first_copy) {
1693 r10_bio->master_bio = bio;
1694 set_bit(R10BIO_Discard, &r10_bio->state);
1695 first_copy = false;
1696 first_r10bio = r10_bio;
1697 } else
> 1698 r10_bio->master_bio = (struct bio *)first_r10bio;
1699
1700 rcu_read_lock();
1701 for (disk = 0; disk < geo->raid_disks; disk++) {
1702 struct md_rdev *rdev = rcu_dereference(conf->mirrors[disk].rdev);
1703 struct md_rdev *rrdev = rcu_dereference(
1704 conf->mirrors[disk].replacement);
1705
1706 r10_bio->devs[disk].bio = NULL;
1707 r10_bio->devs[disk].repl_bio = NULL;
1708
1709 if (rdev && (test_bit(Faulty, &rdev->flags)))
1710 rdev = NULL;
1711 if (rrdev && (test_bit(Faulty, &rrdev->flags)))
1712 rrdev = NULL;
1713 if (!rdev && !rrdev)
1714 continue;
1715
1716 if (rdev) {
1717 r10_bio->devs[disk].bio = bio;
1718 atomic_inc(&rdev->nr_pending);
1719 }
1720 if (rrdev) {
1721 r10_bio->devs[disk].repl_bio = bio;
1722 atomic_inc(&rrdev->nr_pending);
1723 }
1724 }
1725 rcu_read_unlock();
1726
1727 atomic_set(&r10_bio->remaining, 1);
1728 for (disk = 0; disk < geo->raid_disks; disk++) {
1729 sector_t dev_start, dev_end;
1730 struct bio *mbio, *rbio = NULL;
1731 struct md_rdev *rdev = rcu_dereference(conf->mirrors[disk].rdev);
1732 struct md_rdev *rrdev = rcu_dereference(
1733 conf->mirrors[disk].replacement);
1734
1735 /*
1736 * Now start to calculate the start and end address for each disk.
1737 * The space between dev_start and dev_end is the discard region.
1738 *
1739 * For dev_start, it needs to consider three conditions:
1740 * 1st, the disk is before start_disk, you can imagine the disk in
1741 * the next stripe. So the dev_start is the start address of next
1742 * stripe.
1743 * 2st, the disk is after start_disk, it means the disk is at the
1744 * same stripe of first disk
1745 * 3st, the first disk itself, we can use start_disk_offset directly
1746 */
1747 if (disk < start_disk_index)
1748 dev_start = (first_stripe_index + 1) * mddev->chunk_sectors;
1749 else if (disk > start_disk_index)
1750 dev_start = first_stripe_index * mddev->chunk_sectors;
1751 else
1752 dev_start = start_disk_offset;
1753
1754 if (disk < end_disk_index)
1755 dev_end = (last_stripe_index + 1) * mddev->chunk_sectors;
1756 else if (disk > end_disk_index)
1757 dev_end = last_stripe_index * mddev->chunk_sectors;
1758 else
1759 dev_end = end_disk_offset;
1760
1761 /* It only handles discard bio which size is >= stripe size, so
1762 * dev_end > dev_start all the time
1763 */
1764 if (r10_bio->devs[disk].bio) {
1765 mbio = bio_clone_fast(bio, GFP_NOIO, &mddev->bio_set);
1766 mbio->bi_end_io = raid10_end_discard_request;
1767 mbio->bi_private = r10_bio;
1768 r10_bio->devs[disk].bio = mbio;
1769 r10_bio->devs[disk].devnum = disk;
1770 atomic_inc(&r10_bio->remaining);
1771 md_submit_discard_bio(mddev, rdev, mbio,
1772 dev_start + choose_data_offset(r10_bio, rdev),
1773 dev_end - dev_start);
1774 bio_endio(mbio);
1775 }
1776 if (r10_bio->devs[disk].repl_bio) {
1777 rbio = bio_clone_fast(bio, GFP_NOIO, &mddev->bio_set);
1778 rbio->bi_end_io = raid10_end_discard_request;
1779 rbio->bi_private = r10_bio;
1780 r10_bio->devs[disk].repl_bio = rbio;
1781 r10_bio->devs[disk].devnum = disk;
1782 atomic_inc(&r10_bio->remaining);
1783 md_submit_discard_bio(mddev, rrdev, rbio,
1784 dev_start + choose_data_offset(r10_bio, rrdev),
1785 dev_end - dev_start);
1786 bio_endio(rbio);
1787 }
1788 }
1789
1790 if (!geo->far_offset && --far_copies) {
1791 first_stripe_index += geo->stride >> geo->chunk_shift;
1792 start_disk_offset += geo->stride;
1793 last_stripe_index += geo->stride >> geo->chunk_shift;
1794 end_disk_offset += geo->stride;
1795 atomic_inc(&first_r10bio->remaining);
1796 raid_end_discard_bio(r10_bio);
1797 wait_barrier(conf);
1798 goto retry_discard;
1799 }
1800
1801 raid_end_discard_bio(r10_bio);
1802
1803 return 0;
1804 out:
1805 allow_barrier(conf);
1806 return -EAGAIN;
1807 }
1808
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@lists.01.org
Powered by blists - more mailing lists