Skip to content

Commit 3a0f007

Browse files
YuKuai-huaweiliu-song-6
YuKuai-huawei
authored and
liu-song-6
committed
md: add a new helper rdev_has_badblock()
The current api is_badblock() must pass in 'first_bad' and 'bad_sectors', however, many caller just want to know if there are badblocks or not, and these caller must define two local variable that will never be used. Add a new helper rdev_has_badblock() that will only return if there are badblocks or not, remove unnecessary local variables and replace is_badblock() with the new helper in many places. There are no functional changes, and the new helper will also be used later to refactor read_balance(). Co-developed-by: Paul Luse <paul.e.luse@linux.intel.com> Signed-off-by: Paul Luse <paul.e.luse@linux.intel.com> Signed-off-by: Yu Kuai <yukuai3@huawei.com> Reviewed-by: Xiao Ni <xni@redhat.com> Signed-off-by: Song Liu <song@kernel.org> Link: https://lore.kernel.org/r/20240229095714.926789-2-yukuai1@huaweicloud.com
1 parent dfd2bf4 commit 3a0f007

4 files changed

Lines changed: 44 additions & 72 deletions

File tree

‎drivers/md/md.h‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -222,6 +222,16 @@ static inline int is_badblock(struct md_rdev *rdev, sector_t s, int sectors,
222222
}
223223
return 0;
224224
}
225+
226+
static inline int rdev_has_badblock(struct md_rdev *rdev, sector_t s,
227+
int sectors)
228+
{
229+
sector_t first_bad;
230+
int bad_sectors;
231+
232+
return is_badblock(rdev, s, sectors, &first_bad, &bad_sectors);
233+
}
234+
225235
extern int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
226236
int is_new);
227237
extern int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors,

‎drivers/md/raid1.c‎

Lines changed: 7 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -498,9 +498,6 @@ static void raid1_end_write_request(struct bio *bio)
498498
* to user-side. So if something waits for IO, then it
499499
* will wait for the 'master' bio.
500500
*/
501-
sector_t first_bad;
502-
int bad_sectors;
503-
504501
r1_bio->bios[mirror] = NULL;
505502
to_put = bio;
506503
/*
@@ -516,8 +513,8 @@ static void raid1_end_write_request(struct bio *bio)
516513
set_bit(R1BIO_Uptodate, &r1_bio->state);
517514

518515
/* Maybe we can clear some bad blocks. */
519-
if (is_badblock(rdev, r1_bio->sector, r1_bio->sectors,
520-
&first_bad, &bad_sectors) && !discard_error) {
516+
if (rdev_has_badblock(rdev, r1_bio->sector, r1_bio->sectors) &&
517+
!discard_error) {
521518
r1_bio->bios[mirror] = IO_MADE_GOOD;
522519
set_bit(R1BIO_MadeGood, &r1_bio->state);
523520
}
@@ -1944,8 +1941,6 @@ static void end_sync_write(struct bio *bio)
19441941
struct r1bio *r1_bio = get_resync_r1bio(bio);
19451942
struct mddev *mddev = r1_bio->mddev;
19461943
struct r1conf *conf = mddev->private;
1947-
sector_t first_bad;
1948-
int bad_sectors;
19491944
struct md_rdev *rdev = conf->mirrors[find_bio_disk(r1_bio, bio)].rdev;
19501945

19511946
if (!uptodate) {
@@ -1955,14 +1950,11 @@ static void end_sync_write(struct bio *bio)
19551950
set_bit(MD_RECOVERY_NEEDED, &
19561951
mddev->recovery);
19571952
set_bit(R1BIO_WriteError, &r1_bio->state);
1958-
} else if (is_badblock(rdev, r1_bio->sector, r1_bio->sectors,
1959-
&first_bad, &bad_sectors) &&
1960-
!is_badblock(conf->mirrors[r1_bio->read_disk].rdev,
1961-
r1_bio->sector,
1962-
r1_bio->sectors,
1963-
&first_bad, &bad_sectors)
1964-
)
1953+
} else if (rdev_has_badblock(rdev, r1_bio->sector, r1_bio->sectors) &&
1954+
!rdev_has_badblock(conf->mirrors[r1_bio->read_disk].rdev,
1955+
r1_bio->sector, r1_bio->sectors)) {
19651956
set_bit(R1BIO_MadeGood, &r1_bio->state);
1957+
}
19661958

19671959
put_sync_write_buf(r1_bio, uptodate);
19681960
}
@@ -2279,16 +2271,12 @@ static void fix_read_error(struct r1conf *conf, struct r1bio *r1_bio)
22792271
s = PAGE_SIZE >> 9;
22802272

22812273
do {
2282-
sector_t first_bad;
2283-
int bad_sectors;
2284-
22852274
rdev = conf->mirrors[d].rdev;
22862275
if (rdev &&
22872276
(test_bit(In_sync, &rdev->flags) ||
22882277
(!test_bit(Faulty, &rdev->flags) &&
22892278
rdev->recovery_offset >= sect + s)) &&
2290-
is_badblock(rdev, sect, s,
2291-
&first_bad, &bad_sectors) == 0) {
2279+
rdev_has_badblock(rdev, sect, s) == 0) {
22922280
atomic_inc(&rdev->nr_pending);
22932281
if (sync_page_io(rdev, sect, s<<9,
22942282
conf->tmppage, REQ_OP_READ, false))

‎drivers/md/raid10.c‎

Lines changed: 14 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -518,11 +518,7 @@ static void raid10_end_write_request(struct bio *bio)
518518
* The 'master' represents the composite IO operation to
519519
* user-side. So if something waits for IO, then it will
520520
* wait for the 'master' bio.
521-
*/
522-
sector_t first_bad;
523-
int bad_sectors;
524-
525-
/*
521+
*
526522
* Do not set R10BIO_Uptodate if the current device is
527523
* rebuilding or Faulty. This is because we cannot use
528524
* such device for properly reading the data back (we could
@@ -535,10 +531,9 @@ static void raid10_end_write_request(struct bio *bio)
535531
set_bit(R10BIO_Uptodate, &r10_bio->state);
536532

537533
/* Maybe we can clear some bad blocks. */
538-
if (is_badblock(rdev,
539-
r10_bio->devs[slot].addr,
540-
r10_bio->sectors,
541-
&first_bad, &bad_sectors) && !discard_error) {
534+
if (rdev_has_badblock(rdev, r10_bio->devs[slot].addr,
535+
r10_bio->sectors) &&
536+
!discard_error) {
542537
bio_put(bio);
543538
if (repl)
544539
r10_bio->devs[slot].repl_bio = IO_MADE_GOOD;
@@ -1330,10 +1325,7 @@ static void wait_blocked_dev(struct mddev *mddev, struct r10bio *r10_bio)
13301325
}
13311326

13321327
if (rdev && test_bit(WriteErrorSeen, &rdev->flags)) {
1333-
sector_t first_bad;
13341328
sector_t dev_sector = r10_bio->devs[i].addr;
1335-
int bad_sectors;
1336-
int is_bad;
13371329

13381330
/*
13391331
* Discard request doesn't care the write result
@@ -1342,9 +1334,8 @@ static void wait_blocked_dev(struct mddev *mddev, struct r10bio *r10_bio)
13421334
if (!r10_bio->sectors)
13431335
continue;
13441336

1345-
is_bad = is_badblock(rdev, dev_sector, r10_bio->sectors,
1346-
&first_bad, &bad_sectors);
1347-
if (is_bad < 0) {
1337+
if (rdev_has_badblock(rdev, dev_sector,
1338+
r10_bio->sectors) < 0) {
13481339
/*
13491340
* Mustn't write here until the bad block
13501341
* is acknowledged
@@ -2290,8 +2281,6 @@ static void end_sync_write(struct bio *bio)
22902281
struct mddev *mddev = r10_bio->mddev;
22912282
struct r10conf *conf = mddev->private;
22922283
int d;
2293-
sector_t first_bad;
2294-
int bad_sectors;
22952284
int slot;
22962285
int repl;
22972286
struct md_rdev *rdev = NULL;
@@ -2312,11 +2301,10 @@ static void end_sync_write(struct bio *bio)
23122301
&rdev->mddev->recovery);
23132302
set_bit(R10BIO_WriteError, &r10_bio->state);
23142303
}
2315-
} else if (is_badblock(rdev,
2316-
r10_bio->devs[slot].addr,
2317-
r10_bio->sectors,
2318-
&first_bad, &bad_sectors))
2304+
} else if (rdev_has_badblock(rdev, r10_bio->devs[slot].addr,
2305+
r10_bio->sectors)) {
23192306
set_bit(R10BIO_MadeGood, &r10_bio->state);
2307+
}
23202308

23212309
rdev_dec_pending(rdev, mddev);
23222310

@@ -2597,11 +2585,8 @@ static void recovery_request_write(struct mddev *mddev, struct r10bio *r10_bio)
25972585
static int r10_sync_page_io(struct md_rdev *rdev, sector_t sector,
25982586
int sectors, struct page *page, enum req_op op)
25992587
{
2600-
sector_t first_bad;
2601-
int bad_sectors;
2602-
2603-
if (is_badblock(rdev, sector, sectors, &first_bad, &bad_sectors)
2604-
&& (op == REQ_OP_READ || test_bit(WriteErrorSeen, &rdev->flags)))
2588+
if (rdev_has_badblock(rdev, sector, sectors) &&
2589+
(op == REQ_OP_READ || test_bit(WriteErrorSeen, &rdev->flags)))
26052590
return -1;
26062591
if (sync_page_io(rdev, sector, sectors << 9, page, op, false))
26072592
/* success */
@@ -2658,16 +2643,14 @@ static void fix_read_error(struct r10conf *conf, struct mddev *mddev, struct r10
26582643
s = PAGE_SIZE >> 9;
26592644

26602645
do {
2661-
sector_t first_bad;
2662-
int bad_sectors;
2663-
26642646
d = r10_bio->devs[sl].devnum;
26652647
rdev = conf->mirrors[d].rdev;
26662648
if (rdev &&
26672649
test_bit(In_sync, &rdev->flags) &&
26682650
!test_bit(Faulty, &rdev->flags) &&
2669-
is_badblock(rdev, r10_bio->devs[sl].addr + sect, s,
2670-
&first_bad, &bad_sectors) == 0) {
2651+
rdev_has_badblock(rdev,
2652+
r10_bio->devs[sl].addr + sect,
2653+
s) == 0) {
26712654
atomic_inc(&rdev->nr_pending);
26722655
success = sync_page_io(rdev,
26732656
r10_bio->devs[sl].addr +

‎drivers/md/raid5.c‎

Lines changed: 13 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1210,10 +1210,8 @@ static void ops_run_io(struct stripe_head *sh, struct stripe_head_state *s)
12101210
*/
12111211
while (op_is_write(op) && rdev &&
12121212
test_bit(WriteErrorSeen, &rdev->flags)) {
1213-
sector_t first_bad;
1214-
int bad_sectors;
1215-
int bad = is_badblock(rdev, sh->sector, RAID5_STRIPE_SECTORS(conf),
1216-
&first_bad, &bad_sectors);
1213+
int bad = rdev_has_badblock(rdev, sh->sector,
1214+
RAID5_STRIPE_SECTORS(conf));
12171215
if (!bad)
12181216
break;
12191217

@@ -2855,8 +2853,6 @@ static void raid5_end_write_request(struct bio *bi)
28552853
struct r5conf *conf = sh->raid_conf;
28562854
int disks = sh->disks, i;
28572855
struct md_rdev *rdev;
2858-
sector_t first_bad;
2859-
int bad_sectors;
28602856
int replacement = 0;
28612857

28622858
for (i = 0 ; i < disks; i++) {
@@ -2888,9 +2884,8 @@ static void raid5_end_write_request(struct bio *bi)
28882884
if (replacement) {
28892885
if (bi->bi_status)
28902886
md_error(conf->mddev, rdev);
2891-
else if (is_badblock(rdev, sh->sector,
2892-
RAID5_STRIPE_SECTORS(conf),
2893-
&first_bad, &bad_sectors))
2887+
else if (rdev_has_badblock(rdev, sh->sector,
2888+
RAID5_STRIPE_SECTORS(conf)))
28942889
set_bit(R5_MadeGoodRepl, &sh->dev[i].flags);
28952890
} else {
28962891
if (bi->bi_status) {
@@ -2900,9 +2895,8 @@ static void raid5_end_write_request(struct bio *bi)
29002895
if (!test_and_set_bit(WantReplacement, &rdev->flags))
29012896
set_bit(MD_RECOVERY_NEEDED,
29022897
&rdev->mddev->recovery);
2903-
} else if (is_badblock(rdev, sh->sector,
2904-
RAID5_STRIPE_SECTORS(conf),
2905-
&first_bad, &bad_sectors)) {
2898+
} else if (rdev_has_badblock(rdev, sh->sector,
2899+
RAID5_STRIPE_SECTORS(conf))) {
29062900
set_bit(R5_MadeGood, &sh->dev[i].flags);
29072901
if (test_bit(R5_ReadError, &sh->dev[i].flags))
29082902
/* That was a successful write so make
@@ -4674,8 +4668,6 @@ static void analyse_stripe(struct stripe_head *sh, struct stripe_head_state *s)
46744668
/* Now to look around and see what can be done */
46754669
for (i=disks; i--; ) {
46764670
struct md_rdev *rdev;
4677-
sector_t first_bad;
4678-
int bad_sectors;
46794671
int is_bad = 0;
46804672

46814673
dev = &sh->dev[i];
@@ -4719,8 +4711,8 @@ static void analyse_stripe(struct stripe_head *sh, struct stripe_head_state *s)
47194711
rdev = conf->disks[i].replacement;
47204712
if (rdev && !test_bit(Faulty, &rdev->flags) &&
47214713
rdev->recovery_offset >= sh->sector + RAID5_STRIPE_SECTORS(conf) &&
4722-
!is_badblock(rdev, sh->sector, RAID5_STRIPE_SECTORS(conf),
4723-
&first_bad, &bad_sectors))
4714+
!rdev_has_badblock(rdev, sh->sector,
4715+
RAID5_STRIPE_SECTORS(conf)))
47244716
set_bit(R5_ReadRepl, &dev->flags);
47254717
else {
47264718
if (rdev && !test_bit(Faulty, &rdev->flags))
@@ -4733,8 +4725,8 @@ static void analyse_stripe(struct stripe_head *sh, struct stripe_head_state *s)
47334725
if (rdev && test_bit(Faulty, &rdev->flags))
47344726
rdev = NULL;
47354727
if (rdev) {
4736-
is_bad = is_badblock(rdev, sh->sector, RAID5_STRIPE_SECTORS(conf),
4737-
&first_bad, &bad_sectors);
4728+
is_bad = rdev_has_badblock(rdev, sh->sector,
4729+
RAID5_STRIPE_SECTORS(conf));
47384730
if (s->blocked_rdev == NULL
47394731
&& (test_bit(Blocked, &rdev->flags)
47404732
|| is_bad < 0)) {
@@ -5463,8 +5455,8 @@ static int raid5_read_one_chunk(struct mddev *mddev, struct bio *raid_bio)
54635455
struct r5conf *conf = mddev->private;
54645456
struct bio *align_bio;
54655457
struct md_rdev *rdev;
5466-
sector_t sector, end_sector, first_bad;
5467-
int bad_sectors, dd_idx;
5458+
sector_t sector, end_sector;
5459+
int dd_idx;
54685460
bool did_inc;
54695461

54705462
if (!in_chunk_boundary(mddev, raid_bio)) {
@@ -5493,8 +5485,7 @@ static int raid5_read_one_chunk(struct mddev *mddev, struct bio *raid_bio)
54935485

54945486
atomic_inc(&rdev->nr_pending);
54955487

5496-
if (is_badblock(rdev, sector, bio_sectors(raid_bio), &first_bad,
5497-
&bad_sectors)) {
5488+
if (rdev_has_badblock(rdev, sector, bio_sectors(raid_bio))) {
54985489
rdev_dec_pending(rdev, mddev);
54995490
return 0;
55005491
}

0 commit comments

Comments
 (0)