[linux-next:master 6117/8451] drivers/md/raid10.c:1707:39: warning: Uninitialized variable: first_r10bio [uninitvar]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



tree:   https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git master
head:   4143e05b7b171902f4938614c2a68821e1af46bc
commit: 254c271da0712ea8914f187588e0f81f7678ee2f [6117/8451] md/raid10: improve discard request for far layout
compiler: aarch64-linux-gcc (GCC) 9.3.0

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@xxxxxxxxx>


cppcheck warnings: (new ones prefixed by >>)
   In file included from drivers/md/raid10.c:
>> drivers/md/raid10.c:1707:39: warning: Uninitialized variable: first_r10bio [uninitvar]
     r10_bio->master_bio = (struct bio *)first_r10bio;
                                         ^

vim +1707 drivers/md/raid10.c

  1573	
  1574	/*
  1575	 * There are some limitations to handle discard bio
  1576	 * 1st, the discard size is bigger than stripe_size*2.
  1577	 * 2st, if the discard bio spans reshape progress, we use the old way to
  1578	 * handle discard bio
  1579	 */
  1580	static int raid10_handle_discard(struct mddev *mddev, struct bio *bio)
  1581	{
  1582		struct r10conf *conf = mddev->private;
  1583		struct geom *geo = &conf->geo;
  1584		int far_copies = geo->far_copies;
  1585		bool first_copy = true;
  1586		struct r10bio *r10_bio, *first_r10bio;
  1587		struct bio *split;
  1588		int disk;
  1589		sector_t chunk;
  1590		unsigned int stripe_size;
  1591		unsigned int stripe_data_disks;
  1592		sector_t split_size;
  1593		sector_t bio_start, bio_end;
  1594		sector_t first_stripe_index, last_stripe_index;
  1595		sector_t start_disk_offset;
  1596		unsigned int start_disk_index;
  1597		sector_t end_disk_offset;
  1598		unsigned int end_disk_index;
  1599		unsigned int remainder;
  1600	
  1601		if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
  1602			return -EAGAIN;
  1603	
  1604		wait_barrier(conf);
  1605	
  1606		/*
  1607		 * Check reshape again to avoid reshape happens after checking
  1608		 * MD_RECOVERY_RESHAPE and before wait_barrier
  1609		 */
  1610		if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
  1611			goto out;
  1612	
  1613		if (geo->near_copies)
  1614			stripe_data_disks = geo->raid_disks / geo->near_copies +
  1615						geo->raid_disks % geo->near_copies;
  1616		else
  1617			stripe_data_disks = geo->raid_disks;
  1618	
  1619		stripe_size = stripe_data_disks << geo->chunk_shift;
  1620	
  1621		bio_start = bio->bi_iter.bi_sector;
  1622		bio_end = bio_end_sector(bio);
  1623	
  1624		/*
  1625		 * Maybe one discard bio is smaller than strip size or across one
  1626		 * stripe and discard region is larger than one stripe size. For far
  1627		 * offset layout, if the discard region is not aligned with stripe
  1628		 * size, there is hole when we submit discard bio to member disk.
  1629		 * For simplicity, we only handle discard bio which discard region
  1630		 * is bigger than stripe_size * 2
  1631		 */
  1632		if (bio_sectors(bio) < stripe_size*2)
  1633			goto out;
  1634	
  1635		/*
  1636		 * Keep bio aligned with strip size.
  1637		 */
  1638		div_u64_rem(bio_start, stripe_size, &remainder);
  1639		if (remainder) {
  1640			split_size = stripe_size - remainder;
  1641			split = bio_split(bio, split_size, GFP_NOIO, &conf->bio_split);
  1642			bio_chain(split, bio);
  1643			allow_barrier(conf);
  1644			/* Resend the fist split part */
  1645			submit_bio_noacct(split);
  1646			wait_barrier(conf);
  1647		}
  1648		div_u64_rem(bio_end, stripe_size, &remainder);
  1649		if (remainder) {
  1650			split_size = bio_sectors(bio) - remainder;
  1651			split = bio_split(bio, split_size, GFP_NOIO, &conf->bio_split);
  1652			bio_chain(split, bio);
  1653			allow_barrier(conf);
  1654			/* Resend the second split part */
  1655			submit_bio_noacct(bio);
  1656			bio = split;
  1657			wait_barrier(conf);
  1658		}
  1659	
  1660		bio_start = bio->bi_iter.bi_sector;
  1661		bio_end = bio_end_sector(bio);
  1662	
  1663		/*
  1664		 * Raid10 uses chunk as the unit to store data. It's similar like raid0.
  1665		 * One stripe contains the chunks from all member disk (one chunk from
  1666		 * one disk at the same HBA address). For layout detail, see 'man md 4'
  1667		 */
  1668		chunk = bio_start >> geo->chunk_shift;
  1669		chunk *= geo->near_copies;
  1670		first_stripe_index = chunk;
  1671		start_disk_index = sector_div(first_stripe_index, geo->raid_disks);
  1672		if (geo->far_offset)
  1673			first_stripe_index *= geo->far_copies;
  1674		start_disk_offset = (bio_start & geo->chunk_mask) +
  1675					(first_stripe_index << geo->chunk_shift);
  1676	
  1677		chunk = bio_end >> geo->chunk_shift;
  1678		chunk *= geo->near_copies;
  1679		last_stripe_index = chunk;
  1680		end_disk_index = sector_div(last_stripe_index, geo->raid_disks);
  1681		if (geo->far_offset)
  1682			last_stripe_index *= geo->far_copies;
  1683		end_disk_offset = (bio_end & geo->chunk_mask) +
  1684					(last_stripe_index << geo->chunk_shift);
  1685	
  1686	retry_discard:
  1687		r10_bio = mempool_alloc(&conf->r10bio_pool, GFP_NOIO);
  1688		r10_bio->mddev = mddev;
  1689		r10_bio->state = 0;
  1690		r10_bio->sectors = 0;
  1691		memset(r10_bio->devs, 0, sizeof(r10_bio->devs[0]) * geo->raid_disks);
  1692		wait_blocked_dev(mddev, r10_bio);
  1693	
  1694		/*
  1695		 * For far layout it needs more than one r10bio to cover all regions.
  1696		 * Inspired by raid10_sync_request, we can use the first r10bio->master_bio
  1697		 * to record the discard bio. Other r10bio->master_bio record the first
  1698		 * r10bio. The first r10bio only release after all other r10bios finish.
  1699		 * The discard bio returns only first r10bio finishes
  1700		 */
  1701		if (first_copy) {
  1702			r10_bio->master_bio = bio;
  1703			set_bit(R10BIO_Discard, &r10_bio->state);
  1704			first_copy = false;
  1705			first_r10bio = r10_bio;
  1706		} else
> 1707			r10_bio->master_bio = (struct bio *)first_r10bio;
  1708	
  1709		rcu_read_lock();
  1710		for (disk = 0; disk < geo->raid_disks; disk++) {
  1711			struct md_rdev *rdev = rcu_dereference(conf->mirrors[disk].rdev);
  1712			struct md_rdev *rrdev = rcu_dereference(
  1713				conf->mirrors[disk].replacement);
  1714	
  1715			r10_bio->devs[disk].bio = NULL;
  1716			r10_bio->devs[disk].repl_bio = NULL;
  1717	
  1718			if (rdev && (test_bit(Faulty, &rdev->flags)))
  1719				rdev = NULL;
  1720			if (rrdev && (test_bit(Faulty, &rrdev->flags)))
  1721				rrdev = NULL;
  1722			if (!rdev && !rrdev)
  1723				continue;
  1724	
  1725			if (rdev) {
  1726				r10_bio->devs[disk].bio = bio;
  1727				atomic_inc(&rdev->nr_pending);
  1728			}
  1729			if (rrdev) {
  1730				r10_bio->devs[disk].repl_bio = bio;
  1731				atomic_inc(&rrdev->nr_pending);
  1732			}
  1733		}
  1734		rcu_read_unlock();
  1735	
  1736		atomic_set(&r10_bio->remaining, 1);
  1737		for (disk = 0; disk < geo->raid_disks; disk++) {
  1738			sector_t dev_start, dev_end;
  1739			struct bio *mbio, *rbio = NULL;
  1740			struct md_rdev *rdev = rcu_dereference(conf->mirrors[disk].rdev);
  1741			struct md_rdev *rrdev = rcu_dereference(
  1742				conf->mirrors[disk].replacement);
  1743	
  1744			/*
  1745			 * Now start to calculate the start and end address for each disk.
  1746			 * The space between dev_start and dev_end is the discard region.
  1747			 *
  1748			 * For dev_start, it needs to consider three conditions:
  1749			 * 1st, the disk is before start_disk, you can imagine the disk in
  1750			 * the next stripe. So the dev_start is the start address of next
  1751			 * stripe.
  1752			 * 2st, the disk is after start_disk, it means the disk is at the
  1753			 * same stripe of first disk
  1754			 * 3st, the first disk itself, we can use start_disk_offset directly
  1755			 */
  1756			if (disk < start_disk_index)
  1757				dev_start = (first_stripe_index + 1) * mddev->chunk_sectors;
  1758			else if (disk > start_disk_index)
  1759				dev_start = first_stripe_index * mddev->chunk_sectors;
  1760			else
  1761				dev_start = start_disk_offset;
  1762	
  1763			if (disk < end_disk_index)
  1764				dev_end = (last_stripe_index + 1) * mddev->chunk_sectors;
  1765			else if (disk > end_disk_index)
  1766				dev_end = last_stripe_index * mddev->chunk_sectors;
  1767			else
  1768				dev_end = end_disk_offset;
  1769	
  1770			/*
  1771			 * It only handles discard bio which size is >= stripe size, so
  1772			 * dev_end > dev_start all the time
  1773			 */
  1774			if (r10_bio->devs[disk].bio) {
  1775				mbio = bio_clone_fast(bio, GFP_NOIO, &mddev->bio_set);
  1776				mbio->bi_end_io = raid10_end_discard_request;
  1777				mbio->bi_private = r10_bio;
  1778				r10_bio->devs[disk].bio = mbio;
  1779				r10_bio->devs[disk].devnum = disk;
  1780				atomic_inc(&r10_bio->remaining);
  1781				md_submit_discard_bio(mddev, rdev, mbio,
  1782						dev_start + choose_data_offset(r10_bio, rdev),
  1783						dev_end - dev_start);
  1784				bio_endio(mbio);
  1785			}
  1786			if (r10_bio->devs[disk].repl_bio) {
  1787				rbio = bio_clone_fast(bio, GFP_NOIO, &mddev->bio_set);
  1788				rbio->bi_end_io = raid10_end_discard_request;
  1789				rbio->bi_private = r10_bio;
  1790				r10_bio->devs[disk].repl_bio = rbio;
  1791				r10_bio->devs[disk].devnum = disk;
  1792				atomic_inc(&r10_bio->remaining);
  1793				md_submit_discard_bio(mddev, rrdev, rbio,
  1794						dev_start + choose_data_offset(r10_bio, rrdev),
  1795						dev_end - dev_start);
  1796				bio_endio(rbio);
  1797			}
  1798		}
  1799	
  1800		if (!geo->far_offset && --far_copies) {
  1801			first_stripe_index += geo->stride >> geo->chunk_shift;
  1802			start_disk_offset += geo->stride;
  1803			last_stripe_index += geo->stride >> geo->chunk_shift;
  1804			end_disk_offset += geo->stride;
  1805			atomic_inc(&first_r10bio->remaining);
  1806			raid_end_discard_bio(r10_bio);
  1807			wait_barrier(conf);
  1808			goto retry_discard;
  1809		}
  1810	
  1811		raid_end_discard_bio(r10_bio);
  1812	
  1813		return 0;
  1814	out:
  1815		allow_barrier(conf);
  1816		return -EAGAIN;
  1817	}
  1818	

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all@xxxxxxxxxxxx




[Index of Archives]     [Linux ARM Kernel]     [Linux ARM]     [Linux Omap]     [Fedora ARM]     [IETF Annouce]     [Bugtraq]     [Linux OMAP]     [Linux MIPS]     [eCos]     [Asterisk Internet PBX]     [Linux API]

  Powered by Linux