Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483// SPDX-License-Identifier: GPL-2.0-or-later/* * raid1.c : Multiple Devices driver for Linux * * Copyright (C) 1999, 2000, 2001 Ingo Molnar, Red Hat * * Copyright (C) 1996, 1997, 1998 Ingo Molnar, Miguel de Icaza, Gadi Oxman * * RAID-1 management functions. * * Better read-balancing code written by Mika Kuoppala <miku@iki.fi>, 2000 * * Fixes to reconstruction by Jakob Østergaard" <jakob@ostenfeld.dk> * Various fixes by Neil Brown <neilb@cse.unsw.edu.au> * * Changes by Peter T. Breuer <ptb@it.uc3m.es> 31/1/2003 to support * bitmapped intelligence in resync: * * - bitmap marked during normal i/o * - bitmap used to skip nondirty blocks during sync * * Additions to bitmap code, (C) 2003-2004 Paul Clements, SteelEye Technology: * - persistent bitmap code */
#include <linux/slab.h>#include <linux/delay.h>#include <linux/blkdev.h>#include <linux/module.h>#include <linux/seq_file.h>#include <linux/ratelimit.h>#include <linux/interval_tree_generic.h>
#include <trace/events/block.h>
#include "md.h"#include "raid1.h"#include "md-bitmap.h"#include "md-cluster.h"
#define UNSUPPORTED_MDDEV_FLAGS \ ((1L << MD_HAS_JOURNAL) | \ (1L << MD_JOURNAL_CLEAN) | \ (1L << MD_HAS_PPL) | \ (1L << MD_HAS_MULTIPLE_PPLS))
static void allow_barrier(struct r1conf *conf, sector_t sector_nr);static void lower_barrier(struct r1conf *conf, sector_t sector_nr);static void raid1_free(struct mddev *mddev, void *priv);
#define RAID_1_10_NAME "raid1"#include "raid1-10.c"
#define START(node) ((node)->start)#define LAST(node) ((node)->last)INTERVAL_TREE_DEFINE(struct serial_info, node, sector_t, _subtree_last, START, LAST, static inline, raid1_rb);
static int check_and_add_serial(struct md_rdev *rdev, struct r1bio *r1_bio, struct serial_info *si){ unsigned long flags; int ret = 0; sector_t lo = r1_bio->sector; sector_t hi = lo + r1_bio->sectors - 1; int idx = sector_to_idx(r1_bio->sector); struct serial_in_rdev *serial = &rdev->serial[idx]; struct serial_info *head_si;
spin_lock_irqsave(&serial->serial_lock, flags); /* collision happened */ head_si = raid1_rb_iter_first(&serial->serial_rb, lo, hi); if (head_si && head_si != si) { si->start = lo; si->last = hi; si->wnode_start = head_si->wnode_start; list_add_tail(&si->list_node, &head_si->waiters); ret = -EBUSY; } else if (!head_si) { si->start = lo; si->last = hi; si->wnode_start = si->start; raid1_rb_insert(si, &serial->serial_rb); } spin_unlock_irqrestore(&serial->serial_lock, flags);
return ret;}
static void wait_for_serialization(struct md_rdev *rdev, struct r1bio *r1_bio){ struct mddev *mddev = rdev->mddev; struct serial_info *si;
if (WARN_ON(!mddev->serial_info_pool)) return; si = mempool_alloc(mddev->serial_info_pool, GFP_NOIO); INIT_LIST_HEAD(&si->waiters); INIT_LIST_HEAD(&si->list_node); init_completion(&si->ready); while (check_and_add_serial(rdev, r1_bio, si)) { wait_for_completion(&si->ready); reinit_completion(&si->ready); }}
static void remove_serial(struct md_rdev *rdev, sector_t lo, sector_t hi){ struct serial_info *si, *iter_si; unsigned long flags; int found = 0; struct mddev *mddev = rdev->mddev; int idx = sector_to_idx(lo); struct serial_in_rdev *serial = &rdev->serial[idx];
spin_lock_irqsave(&serial->serial_lock, flags); for (si = raid1_rb_iter_first(&serial->serial_rb, lo, hi); si; si = raid1_rb_iter_next(si, lo, hi)) { if (si->start == lo && si->last == hi) { found = 1; break; } } if (found) { raid1_rb_remove(si, &serial->serial_rb); if (!list_empty(&si->waiters)) { list_for_each_entry(iter_si, &si->waiters, list_node) { if (iter_si->wnode_start == si->wnode_start) { list_del_init(&iter_si->list_node); list_splice_init(&si->waiters, &iter_si->waiters); raid1_rb_insert(iter_si, &serial->serial_rb); complete(&iter_si->ready); break; } } } mempool_free(si, mddev->serial_info_pool); } else { WARN(1, "The write IO is not recorded for serialization\n"); } spin_unlock_irqrestore(&serial->serial_lock, flags);}
/* * for resync bio, r1bio pointer can be retrieved from the per-bio * 'struct resync_pages'. */static inline struct r1bio *get_resync_r1bio(struct bio *bio){ return get_resync_pages(bio)->raid_bio;}
static void *r1bio_pool_alloc(gfp_t gfp_flags, struct r1conf *conf){ int size = offsetof(struct r1bio, bios[conf->raid_disks * 2]);
/* allocate a r1bio with room for raid_disks entries in the bios array */ return kzalloc(size, gfp_flags);}
#define RESYNC_DEPTH 32#define RESYNC_SECTORS (RESYNC_BLOCK_SIZE >> 9)#define RESYNC_WINDOW (RESYNC_BLOCK_SIZE * RESYNC_DEPTH)#define RESYNC_WINDOW_SECTORS (RESYNC_WINDOW >> 9)#define CLUSTER_RESYNC_WINDOW (16 * RESYNC_WINDOW)#define CLUSTER_RESYNC_WINDOW_SECTORS (CLUSTER_RESYNC_WINDOW >> 9)
static void * r1buf_pool_alloc(gfp_t gfp_flags, void *data){ struct r1conf *conf = data; struct r1bio *r1_bio; struct bio *bio; int need_pages; int j; struct resync_pages *rps;
r1_bio = r1bio_pool_alloc(gfp_flags, conf); if (!r1_bio) return NULL;
rps = kmalloc_objs(struct resync_pages, conf->raid_disks * 2, gfp_flags); if (!rps) goto out_free_r1bio;
/* * Allocate bios : 1 for reading, n-1 for writing */ for (j = conf->raid_disks * 2; j-- ; ) { bio = bio_kmalloc(RESYNC_PAGES, gfp_flags); if (!bio) goto out_free_bio; bio_init_inline(bio, NULL, RESYNC_PAGES, 0); r1_bio->bios[j] = bio; } /* * Allocate RESYNC_PAGES data pages and attach them to * the first bio. * If this is a user-requested check/repair, allocate * RESYNC_PAGES for each bio. */ if (test_bit(MD_RECOVERY_REQUESTED, &conf->mddev->recovery)) need_pages = conf->raid_disks * 2; else need_pages = 1; for (j = 0; j < conf->raid_disks * 2; j++) { struct resync_pages *rp = &rps[j];
bio = r1_bio->bios[j];
if (j < need_pages) { if (resync_alloc_pages(rp, gfp_flags)) goto out_free_pages; } else { memcpy(rp, &rps[0], sizeof(*rp)); resync_get_all_pages(rp); }
rp->raid_bio = r1_bio; bio->bi_private = rp; }
r1_bio->master_bio = NULL;
return r1_bio;
out_free_pages: while (--j >= 0) resync_free_pages(&rps[j]);
out_free_bio: while (++j < conf->raid_disks * 2) { bio_uninit(r1_bio->bios[j]); kfree(r1_bio->bios[j]); } kfree(rps);
out_free_r1bio: rbio_pool_free(r1_bio, data); return NULL;}
static void r1buf_pool_free(void *__r1_bio, void *data){ struct r1conf *conf = data; int i; struct r1bio *r1bio = __r1_bio; struct resync_pages *rp = NULL;
for (i = conf->raid_disks * 2; i--; ) { rp = get_resync_pages(r1bio->bios[i]); resync_free_pages(rp); bio_uninit(r1bio->bios[i]); kfree(r1bio->bios[i]); }
/* resync pages array stored in the 1st bio's .bi_private */ kfree(rp);
rbio_pool_free(r1bio, data);}
static void put_all_bios(struct r1conf *conf, struct r1bio *r1_bio){ int i;
for (i = 0; i < conf->raid_disks * 2; i++) { struct bio **bio = r1_bio->bios + i; if (!BIO_SPECIAL(*bio)) bio_put(*bio); *bio = NULL; }}
static void free_r1bio(struct r1bio *r1_bio){ struct r1conf *conf = r1_bio->mddev->private;
put_all_bios(conf, r1_bio); mempool_free(r1_bio, conf->r1bio_pool);}
static void put_buf(struct r1bio *r1_bio){ struct r1conf *conf = r1_bio->mddev->private; sector_t sect = r1_bio->sector; int i;
for (i = 0; i < conf->raid_disks * 2; i++) { struct bio *bio = r1_bio->bios[i]; if (bio->bi_end_io) rdev_dec_pending(conf->mirrors[i].rdev, r1_bio->mddev); }
mempool_free(r1_bio, &conf->r1buf_pool);
lower_barrier(conf, sect);}
static void reschedule_retry(struct r1bio *r1_bio){ unsigned long flags; struct mddev *mddev = r1_bio->mddev; struct r1conf *conf = mddev->private; int idx;
idx = sector_to_idx(r1_bio->sector); spin_lock_irqsave(&conf->device_lock, flags); list_add(&r1_bio->retry_list, &conf->retry_list); atomic_inc(&conf->nr_queued[idx]); spin_unlock_irqrestore(&conf->device_lock, flags);
wake_up(&conf->wait_barrier); md_wakeup_thread(mddev->thread);}
/* * raid_end_bio_io() is called when we have finished servicing a mirrored * operation and are ready to return a success/failure code to the buffer * cache layer. */static void call_bio_endio(struct r1bio *r1_bio){ struct bio *bio = r1_bio->master_bio;
if (!test_bit(R1BIO_Uptodate, &r1_bio->state)) bio->bi_status = BLK_STS_IOERR;
bio_endio(bio);}
static void raid_end_bio_io(struct r1bio *r1_bio){ struct bio *bio = r1_bio->master_bio; struct r1conf *conf = r1_bio->mddev->private; sector_t sector = r1_bio->sector;
/* if nobody has done the final endio yet, do it now */ if (!test_and_set_bit(R1BIO_Returned, &r1_bio->state)) { pr_debug("raid1: sync end %s on sectors %llu-%llu\n", (bio_data_dir(bio) == WRITE) ? "write" : "read", (unsigned long long) bio->bi_iter.bi_sector, (unsigned long long) bio_end_sector(bio) - 1);
call_bio_endio(r1_bio); }
free_r1bio(r1_bio); /* * Wake up any possible resync thread that waits for the device * to go idle. All I/Os, even write-behind writes, are done. */ allow_barrier(conf, sector);}
/* * Update disk head position estimator based on IRQ completion info. */static inline void update_head_pos(int disk, struct r1bio *r1_bio){ struct r1conf *conf = r1_bio->mddev->private;
WRITE_ONCE(conf->mirrors[disk].head_position, r1_bio->sector + r1_bio->sectors);}
/* * Find the disk number which triggered given bio */static int find_bio_disk(struct r1bio *r1_bio, struct bio *bio){ int mirror; struct r1conf *conf = r1_bio->mddev->private; int raid_disks = conf->raid_disks;
for (mirror = 0; mirror < raid_disks * 2; mirror++) if (r1_bio->bios[mirror] == bio) break;
BUG_ON(mirror == raid_disks * 2); update_head_pos(mirror, r1_bio);
return mirror;}
static void raid1_end_read_request(struct bio *bio){ int uptodate = !bio->bi_status; struct r1bio *r1_bio = bio->bi_private; struct r1conf *conf = r1_bio->mddev->private; struct md_rdev *rdev = conf->mirrors[r1_bio->read_disk].rdev;
/* * this branch is our 'one mirror IO has finished' event handler: */ update_head_pos(r1_bio->read_disk, r1_bio);
if (uptodate) { set_bit(R1BIO_Uptodate, &r1_bio->state); } else if (test_bit(FailFast, &rdev->flags) && test_bit(R1BIO_FailFast, &r1_bio->state)) { /* This was a fail-fast read so we definitely * want to retry */ ; } else if (!raid1_should_handle_error(bio)) { uptodate = 1; } else { /* If all other devices have failed, we want to return * the error upwards rather than fail the last device. * Here we redefine "uptodate" to mean "Don't want to retry" */ unsigned long flags; spin_lock_irqsave(&conf->device_lock, flags); if (r1_bio->mddev->degraded == conf->raid_disks || (r1_bio->mddev->degraded == conf->raid_disks-1 && test_bit(In_sync, &rdev->flags))) uptodate = 1; spin_unlock_irqrestore(&conf->device_lock, flags); }
if (uptodate) { raid_end_bio_io(r1_bio); rdev_dec_pending(rdev, conf->mddev); } else { /* * oops, read error: */ pr_err_ratelimited("md/raid1:%s: %pg: rescheduling sector %llu\n", mdname(conf->mddev), rdev->bdev, (unsigned long long)r1_bio->sector); set_bit(R1BIO_ReadError, &r1_bio->state); reschedule_retry(r1_bio); /* don't drop the reference on read_disk yet */ }}
static void close_write(struct r1bio *r1_bio){ struct mddev *mddev = r1_bio->mddev;
/* it really is the end of this request */ if (test_bit(R1BIO_BehindIO, &r1_bio->state)) { bio_free_pages(r1_bio->behind_master_bio); bio_put(r1_bio->behind_master_bio); r1_bio->behind_master_bio = NULL; }
if (test_bit(R1BIO_BehindIO, &r1_bio->state)) mddev->bitmap_ops->end_behind_write(mddev); md_write_end(mddev);}
static void r1_bio_write_done(struct r1bio *r1_bio){ if (!atomic_dec_and_test(&r1_bio->remaining)) return;
if (test_bit(R1BIO_WriteError, &r1_bio->state)) reschedule_retry(r1_bio); else { close_write(r1_bio); if (test_bit(R1BIO_MadeGood, &r1_bio->state)) reschedule_retry(r1_bio); else raid_end_bio_io(r1_bio); }}
static void raid1_end_write_request(struct bio *bio){ struct r1bio *r1_bio = bio->bi_private; int behind = test_bit(R1BIO_BehindIO, &r1_bio->state); struct r1conf *conf = r1_bio->mddev->private; struct bio *to_put = NULL; int mirror = find_bio_disk(r1_bio, bio); struct md_rdev *rdev = conf->mirrors[mirror].rdev; sector_t lo = r1_bio->sector; sector_t hi = r1_bio->sector + r1_bio->sectors - 1; bool ignore_error = !raid1_should_handle_error(bio) || (bio->bi_status && bio_op(bio) == REQ_OP_DISCARD);
/* * 'one mirror IO has finished' event handler: */ if (bio->bi_status && !ignore_error) { set_bit(WriteErrorSeen, &rdev->flags); if (!test_and_set_bit(WantReplacement, &rdev->flags)) set_bit(MD_RECOVERY_NEEDED, & conf->mddev->recovery);
if (test_bit(FailFast, &rdev->flags) && (bio->bi_opf & MD_FAILFAST) && /* We never try FailFast to WriteMostly devices */ !test_bit(WriteMostly, &rdev->flags)) { md_error(r1_bio->mddev, rdev); }
/* * When the device is faulty, it is not necessary to * handle write error. */ if (!test_bit(Faulty, &rdev->flags)) set_bit(R1BIO_WriteError, &r1_bio->state); else { /* Finished with this branch */ r1_bio->bios[mirror] = NULL; to_put = bio; } } else { /* * Set R1BIO_Uptodate in our master bio, so that we * will return a good error code for to the higher * levels even if IO on some other mirrored buffer * fails. * * The 'master' represents the composite IO operation * to user-side. So if something waits for IO, then it * will wait for the 'master' bio. */ r1_bio->bios[mirror] = NULL; to_put = bio; /* * Do not set R1BIO_Uptodate if the current device is * rebuilding or Faulty. This is because we cannot use * such device for properly reading the data back (we could * potentially use it, if the current write would have felt * before rdev->recovery_offset, but for simplicity we don't * check this here. */ if (test_bit(In_sync, &rdev->flags) && !test_bit(Faulty, &rdev->flags)) set_bit(R1BIO_Uptodate, &r1_bio->state);
/* Maybe we can clear some bad blocks. */ if (rdev_has_badblock(rdev, r1_bio->sector, r1_bio->sectors) && !ignore_error) { r1_bio->bios[mirror] = IO_MADE_GOOD; set_bit(R1BIO_MadeGood, &r1_bio->state); } }
if (behind) { if (test_bit(CollisionCheck, &rdev->flags)) remove_serial(rdev, lo, hi); if (test_bit(WriteMostly, &rdev->flags)) atomic_dec(&r1_bio->behind_remaining);
/* * In behind mode, we ACK the master bio once the I/O * has safely reached all non-writemostly * disks. Setting the Returned bit ensures that this * gets done only once -- we don't ever want to return * -EIO here, instead we'll wait */ if (atomic_read(&r1_bio->behind_remaining) >= (atomic_read(&r1_bio->remaining)-1) && test_bit(R1BIO_Uptodate, &r1_bio->state)) { /* Maybe we can return now */ if (!test_and_set_bit(R1BIO_Returned, &r1_bio->state)) { struct bio *mbio = r1_bio->master_bio; pr_debug("raid1: behind end write sectors" " %llu-%llu\n", (unsigned long long) mbio->bi_iter.bi_sector, (unsigned long long) bio_end_sector(mbio) - 1); call_bio_endio(r1_bio); } } } else if (test_bit(MD_SERIALIZE_POLICY, &rdev->mddev->flags)) remove_serial(rdev, lo, hi); if (r1_bio->bios[mirror] == NULL) rdev_dec_pending(rdev, conf->mddev);
/* * Let's see if all mirrored write operations have finished * already. */ r1_bio_write_done(r1_bio);
if (to_put) bio_put(to_put);}
static sector_t align_to_barrier_unit_end(sector_t start_sector, sector_t sectors){ sector_t len;
WARN_ON(sectors == 0); /* * len is the number of sectors from start_sector to end of the * barrier unit which start_sector belongs to. */ len = round_up(start_sector + 1, BARRIER_UNIT_SECTOR_SIZE) - start_sector;
if (len > sectors) len = sectors;
return len;}
static void update_read_sectors(struct r1conf *conf, int disk, sector_t this_sector, int len){ struct raid1_info *info = &conf->mirrors[disk];
atomic_inc(&info->rdev->nr_pending); if (READ_ONCE(info->next_seq_sect) != this_sector) WRITE_ONCE(info->seq_start, this_sector); WRITE_ONCE(info->next_seq_sect, this_sector + len);}
static int choose_first_rdev(struct r1conf *conf, struct r1bio *r1_bio, int *max_sectors){ sector_t this_sector = r1_bio->sector; int len = r1_bio->sectors; int disk;
for (disk = 0 ; disk < conf->raid_disks * 2 ; disk++) { struct md_rdev *rdev; int read_len;
if (r1_bio->bios[disk] == IO_BLOCKED) continue;
rdev = conf->mirrors[disk].rdev; if (!rdev || test_bit(Faulty, &rdev->flags)) continue;
/* choose the first disk even if it has some bad blocks. */ read_len = raid1_check_read_range(rdev, this_sector, &len); if (read_len > 0) { update_read_sectors(conf, disk, this_sector, read_len); *max_sectors = read_len; return disk; } }
return -1;}
static bool rdev_in_recovery(struct md_rdev *rdev, struct r1bio *r1_bio){ return !test_bit(In_sync, &rdev->flags) && rdev->recovery_offset < r1_bio->sector + r1_bio->sectors;}
static int choose_bb_rdev(struct r1conf *conf, struct r1bio *r1_bio, int *max_sectors){ sector_t this_sector = r1_bio->sector; int best_disk = -1; int best_len = 0; int disk;
for (disk = 0 ; disk < conf->raid_disks * 2 ; disk++) { struct md_rdev *rdev; int len; int read_len;
if (r1_bio->bios[disk] == IO_BLOCKED) continue;
rdev = conf->mirrors[disk].rdev; if (!rdev || test_bit(Faulty, &rdev->flags) || rdev_in_recovery(rdev, r1_bio) || test_bit(WriteMostly, &rdev->flags)) continue;
/* keep track of the disk with the most readable sectors. */ len = r1_bio->sectors; read_len = raid1_check_read_range(rdev, this_sector, &len); if (read_len > best_len) { best_disk = disk; best_len = read_len; } }
if (best_disk != -1) { *max_sectors = best_len; update_read_sectors(conf, best_disk, this_sector, best_len); }
return best_disk;}
static int choose_slow_rdev(struct r1conf *conf, struct r1bio *r1_bio, int *max_sectors){ sector_t this_sector = r1_bio->sector; int bb_disk = -1; int bb_read_len = 0; int disk;
for (disk = 0 ; disk < conf->raid_disks * 2 ; disk++) { struct md_rdev *rdev; int len; int read_len;
if (r1_bio->bios[disk] == IO_BLOCKED) continue;
rdev = conf->mirrors[disk].rdev; if (!rdev || test_bit(Faulty, &rdev->flags) || !test_bit(WriteMostly, &rdev->flags) || rdev_in_recovery(rdev, r1_bio)) continue;
/* there are no bad blocks, we can use this disk */ len = r1_bio->sectors; read_len = raid1_check_read_range(rdev, this_sector, &len); if (read_len == r1_bio->sectors) { *max_sectors = read_len; update_read_sectors(conf, disk, this_sector, read_len); return disk; }
/* * there are partial bad blocks, choose the rdev with largest * read length. */ if (read_len > bb_read_len) { bb_disk = disk; bb_read_len = read_len; } }
if (bb_disk != -1) { *max_sectors = bb_read_len; update_read_sectors(conf, bb_disk, this_sector, bb_read_len); }
return bb_disk;}
static bool is_sequential(struct r1conf *conf, int disk, struct r1bio *r1_bio){ return READ_ONCE(conf->mirrors[disk].next_seq_sect) == r1_bio->sector || READ_ONCE(conf->mirrors[disk].head_position) == r1_bio->sector;}
/* * If buffered sequential IO size exceeds optimal iosize, check if there is idle * disk. If yes, choose the idle disk. */static bool should_choose_next(struct r1conf *conf, int disk){ struct raid1_info *mirror = &conf->mirrors[disk]; sector_t seq_start, next_seq_sect; int opt_iosize;
if (!test_bit(Nonrot, &mirror->rdev->flags)) return false;
opt_iosize = bdev_io_opt(mirror->rdev->bdev) >> 9; seq_start = READ_ONCE(mirror->seq_start); next_seq_sect = READ_ONCE(mirror->next_seq_sect); return opt_iosize > 0 && seq_start != MaxSector && next_seq_sect > opt_iosize && next_seq_sect - opt_iosize >= seq_start;}
static bool rdev_readable(struct md_rdev *rdev, struct r1bio *r1_bio){ if (!rdev || test_bit(Faulty, &rdev->flags)) return false;
if (rdev_in_recovery(rdev, r1_bio)) return false;
/* don't read from slow disk unless have to */ if (test_bit(WriteMostly, &rdev->flags)) return false;
/* don't split IO for bad blocks unless have to */ if (rdev_has_badblock(rdev, r1_bio->sector, r1_bio->sectors)) return false;
return true;}
struct read_balance_ctl { sector_t closest_dist; int closest_dist_disk; int min_pending; int min_pending_disk; int sequential_disk; int readable_disks;};
static int choose_best_rdev(struct r1conf *conf, struct r1bio *r1_bio){ int disk; struct read_balance_ctl ctl = { .closest_dist_disk = -1, .closest_dist = MaxSector, .min_pending_disk = -1, .min_pending = UINT_MAX, .sequential_disk = -1, };
for (disk = 0 ; disk < conf->raid_disks * 2 ; disk++) { struct md_rdev *rdev; sector_t dist; unsigned int pending;
if (r1_bio->bios[disk] == IO_BLOCKED) continue;
rdev = conf->mirrors[disk].rdev; if (!rdev_readable(rdev, r1_bio)) continue;
/* At least two disks to choose from so failfast is OK */ if (ctl.readable_disks++ == 1) set_bit(R1BIO_FailFast, &r1_bio->state);
pending = atomic_read(&rdev->nr_pending); dist = abs(r1_bio->sector - READ_ONCE(conf->mirrors[disk].head_position));
/* Don't change to another disk for sequential reads */ if (is_sequential(conf, disk, r1_bio)) { if (!should_choose_next(conf, disk)) return disk;
/* * Add 'pending' to avoid choosing this disk if * there is other idle disk. */ pending++; /* * If there is no other idle disk, this disk * will be chosen. */ ctl.sequential_disk = disk; }
if (ctl.min_pending > pending) { ctl.min_pending = pending; ctl.min_pending_disk = disk; }
if (ctl.closest_dist > dist) { ctl.closest_dist = dist; ctl.closest_dist_disk = disk; } }
/* * sequential IO size exceeds optimal iosize, however, there is no other * idle disk, so choose the sequential disk. */ if (ctl.sequential_disk != -1 && ctl.min_pending != 0) return ctl.sequential_disk;
/* * If all disks are rotational, choose the closest disk. If any disk is * non-rotational, choose the disk with less pending request even the * disk is rotational, which might/might not be optimal for raids with * mixed ratation/non-rotational disks depending on workload. */ if (ctl.min_pending_disk != -1 && (READ_ONCE(conf->nonrot_disks) || ctl.min_pending == 0)) return ctl.min_pending_disk; else return ctl.closest_dist_disk;}
/* * This routine returns the disk from which the requested read should be done. * * 1) If resync is in progress, find the first usable disk and use it even if it * has some bad blocks. * * 2) Now that there is no resync, loop through all disks and skipping slow * disks and disks with bad blocks for now. Only pay attention to key disk * choice. * * 3) If we've made it this far, now look for disks with bad blocks and choose * the one with most number of sectors. * * 4) If we are all the way at the end, we have no choice but to use a disk even * if it is write mostly. * * The rdev for the device selected will have nr_pending incremented. */static int read_balance(struct r1conf *conf, struct r1bio *r1_bio, int *max_sectors){ int disk;
clear_bit(R1BIO_FailFast, &r1_bio->state);
if (raid1_should_read_first(conf->mddev, r1_bio->sector, r1_bio->sectors)) return choose_first_rdev(conf, r1_bio, max_sectors);
disk = choose_best_rdev(conf, r1_bio); if (disk >= 0) { *max_sectors = r1_bio->sectors; update_read_sectors(conf, disk, r1_bio->sector, r1_bio->sectors); return disk; }
/* * If we are here it means we didn't find a perfectly good disk so * now spend a bit more time trying to find one with the most good * sectors. */ disk = choose_bb_rdev(conf, r1_bio, max_sectors); if (disk >= 0) return disk;
return choose_slow_rdev(conf, r1_bio, max_sectors);}
static void wake_up_barrier(struct r1conf *conf){ if (wq_has_sleeper(&conf->wait_barrier)) wake_up(&conf->wait_barrier);}
static void flush_bio_list(struct r1conf *conf, struct bio *bio){ /* flush any pending bitmap writes to disk before proceeding w/ I/O */ raid1_prepare_flush_writes(conf->mddev); wake_up_barrier(conf);
while (bio) { /* submit pending writes */ struct bio *next = bio->bi_next;
raid1_submit_write(bio); bio = next; cond_resched(); }}
static void flush_pending_writes(struct r1conf *conf){ /* Any writes that have been queued but are awaiting * bitmap updates get flushed here. */ spin_lock_irq(&conf->device_lock);
if (conf->pending_bio_list.head) { struct blk_plug plug; struct bio *bio;
bio = bio_list_get(&conf->pending_bio_list); spin_unlock_irq(&conf->device_lock);
/* * As this is called in a wait_event() loop (see freeze_array), * current->state might be TASK_UNINTERRUPTIBLE which will * cause a warning when we prepare to wait again. As it is * rare that this path is taken, it is perfectly safe to force * us to go around the wait_event() loop again, so the warning * is a false-positive. Silence the warning by resetting * thread state */ __set_current_state(TASK_RUNNING); blk_start_plug(&plug); flush_bio_list(conf, bio); blk_finish_plug(&plug); } else spin_unlock_irq(&conf->device_lock);}
/* Barriers.... * Sometimes we need to suspend IO while we do something else, * either some resync/recovery, or reconfigure the array. * To do this we raise a 'barrier'. * The 'barrier' is a counter that can be raised multiple times * to count how many activities are happening which preclude * normal IO. * We can only raise the barrier if there is no pending IO. * i.e. if nr_pending == 0. * We choose only to raise the barrier if no-one is waiting for the * barrier to go down. This means that as soon as an IO request * is ready, no other operations which require a barrier will start * until the IO request has had a chance. * * So: regular IO calls 'wait_barrier'. When that returns there * is no backgroup IO happening, It must arrange to call * allow_barrier when it has finished its IO. * backgroup IO calls must call raise_barrier. Once that returns * there is no normal IO happeing. It must arrange to call * lower_barrier when the particular background IO completes. * * If resync/recovery is interrupted, returns -EINTR; * Otherwise, returns 0. */static int raise_barrier(struct r1conf *conf, sector_t sector_nr){ int idx = sector_to_idx(sector_nr);
spin_lock_irq(&conf->resync_lock);
/* Wait until no block IO is waiting */ wait_event_lock_irq(conf->wait_barrier, !atomic_read(&conf->nr_waiting[idx]), conf->resync_lock);
/* block any new IO from starting */ atomic_inc(&conf->barrier[idx]); /* * In raise_barrier() we firstly increase conf->barrier[idx] then * check conf->nr_pending[idx]. In _wait_barrier() we firstly * increase conf->nr_pending[idx] then check conf->barrier[idx]. * A memory barrier here to make sure conf->nr_pending[idx] won't * be fetched before conf->barrier[idx] is increased. Otherwise * there will be a race between raise_barrier() and _wait_barrier(). */ smp_mb__after_atomic();
/* For these conditions we must wait: * A: while the array is in frozen state * B: while conf->nr_pending[idx] is not 0, meaning regular I/O * existing in corresponding I/O barrier bucket. * C: while conf->barrier[idx] >= RESYNC_DEPTH, meaning reaches * max resync count which allowed on current I/O barrier bucket. */ wait_event_lock_irq(conf->wait_barrier, (!conf->array_frozen && !atomic_read(&conf->nr_pending[idx]) && atomic_read(&conf->barrier[idx]) < RESYNC_DEPTH) || test_bit(MD_RECOVERY_INTR, &conf->mddev->recovery), conf->resync_lock);
if (test_bit(MD_RECOVERY_INTR, &conf->mddev->recovery)) { atomic_dec(&conf->barrier[idx]); spin_unlock_irq(&conf->resync_lock); wake_up(&conf->wait_barrier); return -EINTR; }
atomic_inc(&conf->nr_sync_pending); spin_unlock_irq(&conf->resync_lock);
return 0;}
static void lower_barrier(struct r1conf *conf, sector_t sector_nr){ int idx = sector_to_idx(sector_nr);
BUG_ON(atomic_read(&conf->barrier[idx]) <= 0);
atomic_dec(&conf->barrier[idx]); atomic_dec(&conf->nr_sync_pending); wake_up(&conf->wait_barrier);}
static void _wait_barrier(struct r1conf *conf, int idx){ /* * We need to increase conf->nr_pending[idx] very early here, * then raise_barrier() can be blocked when it waits for * conf->nr_pending[idx] to be 0. Then we can avoid holding * conf->resync_lock when there is no barrier raised in same * barrier unit bucket. Also if the array is frozen, I/O * should be blocked until array is unfrozen. */ atomic_inc(&conf->nr_pending[idx]); /* * In _wait_barrier() we firstly increase conf->nr_pending[idx], then * check conf->barrier[idx]. In raise_barrier() we firstly increase * conf->barrier[idx], then check conf->nr_pending[idx]. A memory * barrier is necessary here to make sure conf->barrier[idx] won't be * fetched before conf->nr_pending[idx] is increased. Otherwise there * will be a race between _wait_barrier() and raise_barrier(). */ smp_mb__after_atomic();
/* * Don't worry about checking two atomic_t variables at same time * here. If during we check conf->barrier[idx], the array is * frozen (conf->array_frozen is 1), and chonf->barrier[idx] is * 0, it is safe to return and make the I/O continue. Because the * array is frozen, all I/O returned here will eventually complete * or be queued, no race will happen. See code comment in * frozen_array(). */ if (!READ_ONCE(conf->array_frozen) && !atomic_read(&conf->barrier[idx])) return;
/* * After holding conf->resync_lock, conf->nr_pending[idx] * should be decreased before waiting for barrier to drop. * Otherwise, we may encounter a race condition because * raise_barrer() might be waiting for conf->nr_pending[idx] * to be 0 at same time. */ spin_lock_irq(&conf->resync_lock); atomic_inc(&conf->nr_waiting[idx]); atomic_dec(&conf->nr_pending[idx]); /* * In case freeze_array() is waiting for * get_unqueued_pending() == extra */ wake_up_barrier(conf); /* Wait for the barrier in same barrier unit bucket to drop. */
wait_event_lock_irq(conf->wait_barrier, !conf->array_frozen && !atomic_read(&conf->barrier[idx]), conf->resync_lock);
atomic_inc(&conf->nr_pending[idx]); atomic_dec(&conf->nr_waiting[idx]); spin_unlock_irq(&conf->resync_lock);}
static void wait_read_barrier(struct r1conf *conf, sector_t sector_nr){ int idx = sector_to_idx(sector_nr);
/* * Very similar to _wait_barrier(). The difference is, for read * I/O we don't need wait for sync I/O, but if the whole array * is frozen, the read I/O still has to wait until the array is * unfrozen. Since there is no ordering requirement with * conf->barrier[idx] here, memory barrier is unnecessary as well. */ atomic_inc(&conf->nr_pending[idx]);
if (!READ_ONCE(conf->array_frozen)) return;
spin_lock_irq(&conf->resync_lock); atomic_inc(&conf->nr_waiting[idx]); atomic_dec(&conf->nr_pending[idx]); /* * In case freeze_array() is waiting for * get_unqueued_pending() == extra */ wake_up_barrier(conf); /* Wait for array to be unfrozen */
wait_event_lock_irq(conf->wait_barrier, !conf->array_frozen, conf->resync_lock);
atomic_inc(&conf->nr_pending[idx]); atomic_dec(&conf->nr_waiting[idx]); spin_unlock_irq(&conf->resync_lock);}
static void wait_barrier(struct r1conf *conf, sector_t sector_nr){ int idx = sector_to_idx(sector_nr);
_wait_barrier(conf, idx);}
static void _allow_barrier(struct r1conf *conf, int idx){ atomic_dec(&conf->nr_pending[idx]); wake_up_barrier(conf);}
static void allow_barrier(struct r1conf *conf, sector_t sector_nr){ int idx = sector_to_idx(sector_nr);
_allow_barrier(conf, idx);}
/* conf->resync_lock should be held */static int get_unqueued_pending(struct r1conf *conf){ int idx, ret;
ret = atomic_read(&conf->nr_sync_pending); for (idx = 0; idx < BARRIER_BUCKETS_NR; idx++) ret += atomic_read(&conf->nr_pending[idx]) - atomic_read(&conf->nr_queued[idx]);
return ret;}
static void freeze_array(struct r1conf *conf, int extra){ /* Stop sync I/O and normal I/O and wait for everything to * go quiet. * This is called in two situations: * 1) management command handlers (reshape, remove disk, quiesce). * 2) one normal I/O request failed.
* After array_frozen is set to 1, new sync IO will be blocked at * raise_barrier(), and new normal I/O will blocked at _wait_barrier() * or wait_read_barrier(). The flying I/Os will either complete or be * queued. When everything goes quite, there are only queued I/Os left.
* Every flying I/O contributes to a conf->nr_pending[idx], idx is the * barrier bucket index which this I/O request hits. When all sync and * normal I/O are queued, sum of all conf->nr_pending[] will match sum * of all conf->nr_queued[]. But normal I/O failure is an exception, * in handle_read_error(), we may call freeze_array() before trying to * fix the read error. In this case, the error read I/O is not queued, * so get_unqueued_pending() == 1. * * Therefore before this function returns, we need to wait until * get_unqueued_pendings(conf) gets equal to extra. For * normal I/O context, extra is 1, in rested situations extra is 0. */ spin_lock_irq(&conf->resync_lock); conf->array_frozen = 1; mddev_add_trace_msg(conf->mddev, "raid1 wait freeze"); wait_event_lock_irq_cmd( conf->wait_barrier, get_unqueued_pending(conf) == extra, conf->resync_lock, flush_pending_writes(conf)); spin_unlock_irq(&conf->resync_lock);}static void unfreeze_array(struct r1conf *conf){ /* reverse the effect of the freeze */ spin_lock_irq(&conf->resync_lock); conf->array_frozen = 0; spin_unlock_irq(&conf->resync_lock); wake_up(&conf->wait_barrier);}
static void alloc_behind_master_bio(struct r1bio *r1_bio, struct bio *bio){ int size = bio->bi_iter.bi_size; unsigned vcnt = (size + PAGE_SIZE - 1) >> PAGE_SHIFT; int i = 0; struct bio *behind_bio = NULL;
behind_bio = bio_alloc_bioset(NULL, vcnt, bio->bi_opf, GFP_NOIO, &r1_bio->mddev->bio_set);
/* discard op, we don't support writezero/writesame yet */ if (!bio_has_data(bio)) { behind_bio->bi_iter.bi_size = size; goto skip_copy; }
while (i < vcnt && size) { struct page *page; int len = min_t(int, PAGE_SIZE, size);
page = alloc_page(GFP_NOIO); if (unlikely(!page)) goto free_pages;
if (!bio_add_page(behind_bio, page, len, 0)) { put_page(page); goto free_pages; }
size -= len; i++; }
bio_copy_data(behind_bio, bio);skip_copy: r1_bio->behind_master_bio = behind_bio; set_bit(R1BIO_BehindIO, &r1_bio->state);
return;
free_pages: pr_debug("%dB behind alloc failed, doing sync I/O\n", bio->bi_iter.bi_size); bio_free_pages(behind_bio); bio_put(behind_bio);}
static void raid1_unplug(struct blk_plug_cb *cb, bool from_schedule){ struct raid1_plug_cb *plug = container_of(cb, struct raid1_plug_cb, cb); struct mddev *mddev = plug->cb.data; struct r1conf *conf = mddev->private; struct bio *bio;
if (from_schedule) { spin_lock_irq(&conf->device_lock); bio_list_merge(&conf->pending_bio_list, &plug->pending); spin_unlock_irq(&conf->device_lock); wake_up_barrier(conf); md_wakeup_thread(mddev->thread); kfree(plug); return; }
/* we aren't scheduling, so we can do the write-out directly. */ bio = bio_list_get(&plug->pending); flush_bio_list(conf, bio); kfree(plug);}
static void init_r1bio(struct r1bio *r1_bio, struct mddev *mddev, struct bio *bio){ r1_bio->master_bio = bio; r1_bio->sectors = bio_sectors(bio); r1_bio->state = 0; r1_bio->mddev = mddev; r1_bio->sector = bio->bi_iter.bi_sector;}
static inline struct r1bio *alloc_r1bio(struct mddev *mddev, struct bio *bio){ struct r1conf *conf = mddev->private; struct r1bio *r1_bio;
r1_bio = mempool_alloc(conf->r1bio_pool, GFP_NOIO); memset(r1_bio, 0, offsetof(struct r1bio, bios[conf->raid_disks * 2])); init_r1bio(r1_bio, mddev, bio); return r1_bio;}
static void raid1_read_request(struct mddev *mddev, struct bio *bio, int max_read_sectors, struct r1bio *r1_bio){ struct r1conf *conf = mddev->private; struct raid1_info *mirror; struct bio *read_bio; int max_sectors; int rdisk; bool r1bio_existed = !!r1_bio;
/* * An md cloned bio indicates we are in the error path. * This is more reliable than checking r1_bio, which might * be NULL even in the error path if a failed bio was split. */ bool err_path = md_cloned_bio(mddev, bio);
/* * If we are in the error path, we are blocking the raid1d * thread so there is a tiny risk of deadlock. So ask for * emergency memory if needed. */ gfp_t gfp = err_path ? (GFP_NOIO | __GFP_HIGH) : GFP_NOIO;
/* * Still need barrier for READ in case that whole * array is frozen. */ wait_read_barrier(conf, bio->bi_iter.bi_sector);
if (!r1_bio) r1_bio = alloc_r1bio(mddev, bio); else init_r1bio(r1_bio, mddev, bio); r1_bio->sectors = max_read_sectors;
/* * make_request() can abort the operation when read-ahead is being * used and no empty request is available. */ rdisk = read_balance(conf, r1_bio, &max_sectors); if (rdisk < 0) { /* couldn't find anywhere to read from */ if (r1bio_existed) pr_crit_ratelimited("md/raid1:%s: %pg: unrecoverable I/O read error for block %llu\n", mdname(mddev), conf->mirrors[r1_bio->read_disk].rdev->bdev, r1_bio->sector); raid_end_bio_io(r1_bio); return; } mirror = conf->mirrors + rdisk;
if (r1bio_existed) pr_info_ratelimited("md/raid1:%s: redirecting sector %llu to other mirror: %pg\n", mdname(mddev), (unsigned long long)r1_bio->sector, mirror->rdev->bdev);
if (test_bit(WriteMostly, &mirror->rdev->flags) && md_bitmap_enabled(mddev, false)) { /* * Reading from a write-mostly device must take care not to * over-take any writes that are 'behind' */ mddev_add_trace_msg(mddev, "raid1 wait behind writes"); mddev->bitmap_ops->wait_behind_writes(mddev); }
if (max_sectors < bio_sectors(bio)) { bio = bio_submit_split_bioset(bio, max_sectors, &conf->bio_split); if (!bio) { set_bit(R1BIO_Returned, &r1_bio->state); goto err_handle; }
r1_bio->master_bio = bio; r1_bio->sectors = max_sectors; }
r1_bio->read_disk = rdisk; if (likely(!md_cloned_bio(mddev, bio))) { md_account_bio(mddev, &bio); r1_bio->master_bio = bio; } read_bio = bio_alloc_clone(mirror->rdev->bdev, bio, gfp, &mddev->bio_set); r1_bio->bios[rdisk] = read_bio;
read_bio->bi_iter.bi_sector = r1_bio->sector + mirror->rdev->data_offset; read_bio->bi_end_io = raid1_end_read_request; if (test_bit(FailFast, &mirror->rdev->flags) && test_bit(R1BIO_FailFast, &r1_bio->state)) read_bio->bi_opf |= MD_FAILFAST; read_bio->bi_private = r1_bio; mddev_trace_remap(mddev, read_bio, r1_bio->sector); submit_bio_noacct(read_bio); return;
err_handle: atomic_dec(&mirror->rdev->nr_pending); raid_end_bio_io(r1_bio);}
static void wait_blocked_rdev(struct mddev *mddev, struct bio *bio){ struct r1conf *conf = mddev->private; int disks = conf->raid_disks * 2; int i;
retry: for (i = 0; i < disks; i++) { struct md_rdev *rdev = conf->mirrors[i].rdev;
if (!rdev) continue;
/* don't write here until the bad block is acknowledged */ if (test_bit(WriteErrorSeen, &rdev->flags) && rdev_has_badblock(rdev, bio->bi_iter.bi_sector, bio_sectors(bio)) < 0) set_bit(BlockedBadBlocks, &rdev->flags);
if (rdev_blocked(rdev)) { mddev_add_trace_msg(rdev->mddev, "raid1 wait rdev %d blocked", rdev->raid_disk); atomic_inc(&rdev->nr_pending); md_wait_for_blocked_rdev(rdev, rdev->mddev); goto retry; } }}
static void raid1_start_write_behind(struct mddev *mddev, struct r1bio *r1_bio, struct bio *bio){ unsigned long max_write_behind = mddev->bitmap_info.max_write_behind; struct md_bitmap_stats stats; int err;
/* behind write rely on bitmap, see bitmap_operations */ if (!md_bitmap_enabled(mddev, false)) return;
err = mddev->bitmap_ops->get_stats(mddev->bitmap, &stats); if (err) return;
/* Don't do behind IO if reader is waiting, or there are too many. */ if (!stats.behind_wait && stats.behind_writes < max_write_behind) alloc_behind_master_bio(r1_bio, bio);
if (test_bit(R1BIO_BehindIO, &r1_bio->state)) mddev->bitmap_ops->start_behind_write(mddev);
}
static bool raid1_write_request(struct mddev *mddev, struct bio *bio, int max_sectors){ struct r1conf *conf = mddev->private; struct r1bio *r1_bio; int i, disks, k; unsigned long flags; int first_clone; bool write_behind = false; bool atomic = bio->bi_opf & REQ_ATOMIC; bool is_discard = op_is_discard(bio->bi_opf); sector_t sector = bio->bi_iter.bi_sector;
if (mddev_is_clustered(mddev) && mddev->cluster_ops->area_resyncing(mddev, WRITE, sector, bio_end_sector(bio))) { wait_event_idle(conf->wait_barrier, !mddev->cluster_ops->area_resyncing(mddev, WRITE, sector, bio_end_sector(bio))); }
/* * Register the new request and wait if the reconstruction * thread has put up a bar for new requests. * Continue immediately if no resync is active currently. */ wait_barrier(conf, sector);
wait_blocked_rdev(mddev, bio);
r1_bio = alloc_r1bio(mddev, bio); r1_bio->sectors = max_sectors;
/* first select target devices under rcu_lock and * inc refcount on their rdev. Record them by setting * bios[x] to bio * If there are known/acknowledged bad blocks on any device on * which we have seen a write error, we want to avoid writing those * blocks. * This potentially requires several writes to write around * the bad blocks. Each set of writes gets it's own r1bio * with a set of bios attached. */
disks = conf->raid_disks * 2; for (i = 0; i < disks; i++) { struct md_rdev *rdev = conf->mirrors[i].rdev;
/* * The write-behind io is only attempted on drives marked as * write-mostly, which means we could allocate write behind * bio later. */ if (!is_discard && rdev && test_bit(WriteMostly, &rdev->flags)) write_behind = true; if (atomic && max_sectors > BIO_MAX_VECS * (PAGE_SIZE >> 9)) write_behind = false;
r1_bio->bios[i] = NULL; if (!rdev || test_bit(Faulty, &rdev->flags)) continue;
if (test_bit(WriteErrorSeen, &rdev->flags)) { sector_t first_bad; sector_t bad_sectors; int is_bad;
is_bad = is_badblock(rdev, sector, max_sectors, &first_bad, &bad_sectors); if (is_bad && first_bad <= sector) { /* Cannot write here at all */ bad_sectors -= (sector - first_bad); if (bad_sectors < max_sectors) /* mustn't write more than bad_sectors * to other devices yet */ max_sectors = bad_sectors; continue; } if (is_bad) { int good_sectors;
good_sectors = first_bad - sector; if (good_sectors < max_sectors) max_sectors = good_sectors; } }
atomic_inc(&rdev->nr_pending); r1_bio->bios[i] = bio; }
/* * When using a bitmap, we may call alloc_behind_master_bio below. * alloc_behind_master_bio allocates a copy of the data payload a page * at a time and thus needs a new bio that can fit the whole payload * this bio in page sized chunks. */ if (write_behind && mddev->bitmap) max_sectors = min_t(int, max_sectors, BIO_MAX_VECS * (PAGE_SIZE >> 9)); if (max_sectors < bio_sectors(bio)) { if (atomic) { bio_io_error(bio); goto err_dec_pending; }
bio = bio_submit_split_bioset(bio, max_sectors, &conf->bio_split); if (!bio) goto err_dec_pending;
r1_bio->master_bio = bio; r1_bio->sectors = max_sectors; }
md_account_bio(mddev, &bio); r1_bio->master_bio = bio; atomic_set(&r1_bio->remaining, 1); atomic_set(&r1_bio->behind_remaining, 0);
first_clone = 1;
for (i = 0; i < disks; i++) { struct bio *mbio = NULL; struct md_rdev *rdev = conf->mirrors[i].rdev; if (!r1_bio->bios[i]) continue;
if (first_clone) { if (write_behind) raid1_start_write_behind(mddev, r1_bio, bio); first_clone = 0; }
if (r1_bio->behind_master_bio) { mbio = bio_alloc_clone(rdev->bdev, r1_bio->behind_master_bio, GFP_NOIO, &mddev->bio_set); if (test_bit(CollisionCheck, &rdev->flags)) wait_for_serialization(rdev, r1_bio); if (test_bit(WriteMostly, &rdev->flags)) atomic_inc(&r1_bio->behind_remaining); } else { mbio = bio_alloc_clone(rdev->bdev, bio, GFP_NOIO, &mddev->bio_set);
if (test_bit(MD_SERIALIZE_POLICY, &mddev->flags)) wait_for_serialization(rdev, r1_bio); }
r1_bio->bios[i] = mbio;
mbio->bi_iter.bi_sector = sector + rdev->data_offset; mbio->bi_end_io = raid1_end_write_request; if (test_bit(FailFast, &rdev->flags) && !test_bit(WriteMostly, &rdev->flags) && conf->raid_disks - mddev->degraded > 1) mbio->bi_opf |= MD_FAILFAST; mbio->bi_private = r1_bio;
atomic_inc(&r1_bio->remaining); mddev_trace_remap(mddev, mbio, sector); /* flush_pending_writes() needs access to the rdev so...*/ mbio->bi_bdev = (void *)rdev; if (!raid1_add_bio_to_plug(mddev, mbio, raid1_unplug, disks)) { spin_lock_irqsave(&conf->device_lock, flags); bio_list_add(&conf->pending_bio_list, mbio); spin_unlock_irqrestore(&conf->device_lock, flags); md_wakeup_thread(mddev->thread); } }
r1_bio_write_done(r1_bio);
/* In case raid1d snuck in to freeze_array */ wake_up_barrier(conf);
return true;
err_dec_pending: for (k = 0; k < i; k++) { if (r1_bio->bios[k]) { rdev_dec_pending(conf->mirrors[k].rdev, mddev); r1_bio->bios[k] = NULL; } }
free_r1bio(r1_bio); allow_barrier(conf, sector);
return false;}
static bool raid1_make_request(struct mddev *mddev, struct bio *bio){ sector_t sectors;
if (unlikely(bio->bi_opf & REQ_PREFLUSH) && md_flush_request(mddev, bio)) return true;
/* * There is a limit to the maximum size, but * the read/write handler might find a lower limit * due to bad blocks. To avoid multiple splits, * we pass the maximum number of sectors down * and let the lower level perform the split. */ sectors = align_to_barrier_unit_end( bio->bi_iter.bi_sector, bio_sectors(bio));
if (bio_data_dir(bio) == READ) raid1_read_request(mddev, bio, sectors, NULL); else { md_write_start(mddev, bio); if (!raid1_write_request(mddev, bio, sectors)) md_write_end(mddev); } return true;}
static void raid1_status(struct seq_file *seq, struct mddev *mddev){ struct r1conf *conf = mddev->private; int i;
lockdep_assert_held(&mddev->lock);
seq_printf(seq, " [%d/%d] [", conf->raid_disks, conf->raid_disks - mddev->degraded); for (i = 0; i < conf->raid_disks; i++) { struct md_rdev *rdev = READ_ONCE(conf->mirrors[i].rdev);
seq_printf(seq, "%s", rdev && test_bit(In_sync, &rdev->flags) ? "U" : "_"); } seq_printf(seq, "]");}
/** * raid1_error() - RAID1 error handler. * @mddev: affected md device. * @rdev: member device to fail. * * The routine acknowledges &rdev failure and determines new @mddev state. * If it failed, then: * - &MD_BROKEN flag is set in &mddev->flags. * - recovery is disabled. * Otherwise, it must be degraded: * - recovery is interrupted. * - &mddev->degraded is bumped. * * @rdev is marked as &Faulty excluding case when array is failed and * MD_FAILLAST_DEV is not set. */static void raid1_error(struct mddev *mddev, struct md_rdev *rdev){ struct r1conf *conf = mddev->private; unsigned long flags;
spin_lock_irqsave(&conf->device_lock, flags);
if (test_bit(In_sync, &rdev->flags) && (conf->raid_disks - mddev->degraded) == 1) { set_bit(MD_BROKEN, &mddev->flags);
if (!test_bit(MD_FAILLAST_DEV, &mddev->flags)) { spin_unlock_irqrestore(&conf->device_lock, flags); return; } } set_bit(Blocked, &rdev->flags); if (test_and_clear_bit(In_sync, &rdev->flags)) mddev->degraded++; set_bit(Faulty, &rdev->flags); spin_unlock_irqrestore(&conf->device_lock, flags); /* * if recovery is running, make sure it aborts. */ set_bit(MD_RECOVERY_INTR, &mddev->recovery); set_mask_bits(&mddev->sb_flags, 0, BIT(MD_SB_CHANGE_DEVS) | BIT(MD_SB_CHANGE_PENDING)); pr_crit("md/raid1:%s: Disk failure on %pg, disabling device.\n" "md/raid1:%s: Operation continuing on %d devices.\n", mdname(mddev), rdev->bdev, mdname(mddev), conf->raid_disks - mddev->degraded);}
static void print_conf(struct r1conf *conf){ int i;
pr_debug("RAID1 conf printout:\n"); if (!conf) { pr_debug("(!conf)\n"); return; } pr_debug(" --- wd:%d rd:%d\n", conf->raid_disks - conf->mddev->degraded, conf->raid_disks);
lockdep_assert_held(&conf->mddev->reconfig_mutex); for (i = 0; i < conf->raid_disks; i++) { struct md_rdev *rdev = conf->mirrors[i].rdev; if (rdev) pr_debug(" disk %d, wo:%d, o:%d, dev:%pg\n", i, !test_bit(In_sync, &rdev->flags), !test_bit(Faulty, &rdev->flags), rdev->bdev); }}
static void close_sync(struct r1conf *conf){ int idx;
for (idx = 0; idx < BARRIER_BUCKETS_NR; idx++) { _wait_barrier(conf, idx); _allow_barrier(conf, idx); }
mempool_exit(&conf->r1buf_pool);}
static int raid1_spare_active(struct mddev *mddev){ int i; struct r1conf *conf = mddev->private; int count = 0; unsigned long flags;
/* * Find all failed disks within the RAID1 configuration * and mark them readable. * Called under mddev lock, so rcu protection not needed. * device_lock used to avoid races with raid1_end_read_request * which expects 'In_sync' flags and ->degraded to be consistent. */ spin_lock_irqsave(&conf->device_lock, flags); for (i = 0; i < conf->raid_disks; i++) { struct md_rdev *rdev = conf->mirrors[i].rdev; struct md_rdev *repl = conf->mirrors[conf->raid_disks + i].rdev; if (repl && !test_bit(Candidate, &repl->flags) && repl->recovery_offset == MaxSector && !test_bit(Faulty, &repl->flags) && !test_and_set_bit(In_sync, &repl->flags)) { /* replacement has just become active */ if (!rdev || !test_and_clear_bit(In_sync, &rdev->flags)) count++; if (rdev) { /* Replaced device not technically * faulty, but we need to be sure * it gets removed and never re-added */ set_bit(Faulty, &rdev->flags); sysfs_notify_dirent_safe( rdev->sysfs_state); } } if (rdev && rdev->recovery_offset == MaxSector && !test_bit(Faulty, &rdev->flags) && !test_and_set_bit(In_sync, &rdev->flags)) { count++; sysfs_notify_dirent_safe(rdev->sysfs_state); } } mddev->degraded -= count; spin_unlock_irqrestore(&conf->device_lock, flags);
print_conf(conf); return count;}
static bool raid1_add_conf(struct r1conf *conf, struct md_rdev *rdev, int disk, bool replacement){ struct raid1_info *info = conf->mirrors + disk;
if (replacement) info += conf->raid_disks;
if (info->rdev) return false;
if (!bdev_rot(rdev->bdev)) { set_bit(Nonrot, &rdev->flags); WRITE_ONCE(conf->nonrot_disks, conf->nonrot_disks + 1); }
rdev->raid_disk = disk; info->head_position = 0; info->seq_start = MaxSector; WRITE_ONCE(info->rdev, rdev);
return true;}
static bool raid1_remove_conf(struct r1conf *conf, int disk){ struct raid1_info *info = conf->mirrors + disk; struct md_rdev *rdev = info->rdev;
if (!rdev || test_bit(In_sync, &rdev->flags) || atomic_read(&rdev->nr_pending)) return false;
/* Only remove non-faulty devices if recovery is not possible. */ if (!test_bit(Faulty, &rdev->flags) && rdev->mddev->degraded < conf->raid_disks) return false;
if (test_and_clear_bit(Nonrot, &rdev->flags)) WRITE_ONCE(conf->nonrot_disks, conf->nonrot_disks - 1);
WRITE_ONCE(info->rdev, NULL); return true;}
static int raid1_add_disk(struct mddev *mddev, struct md_rdev *rdev){ struct r1conf *conf = mddev->private; int err = -EEXIST; int mirror = 0, repl_slot = -1; struct raid1_info *p; int first = 0; int last = conf->raid_disks - 1;
if (rdev->raid_disk >= 0) first = last = rdev->raid_disk;
/* * find the disk ... but prefer rdev->saved_raid_disk * if possible. */ if (rdev->saved_raid_disk >= 0 && rdev->saved_raid_disk >= first && rdev->saved_raid_disk < conf->raid_disks && conf->mirrors[rdev->saved_raid_disk].rdev == NULL) first = last = rdev->saved_raid_disk;
for (mirror = first; mirror <= last; mirror++) { p = conf->mirrors + mirror; if (!p->rdev) { err = mddev_stack_new_rdev(mddev, rdev); if (err) return err;
raid1_add_conf(conf, rdev, mirror, false); /* As all devices are equivalent, we don't need a full recovery * if this was recently any drive of the array */ if (rdev->saved_raid_disk < 0) conf->fullsync = 1; break; } if (test_bit(WantReplacement, &p->rdev->flags) && p[conf->raid_disks].rdev == NULL && repl_slot < 0) repl_slot = mirror; }
if (err && repl_slot >= 0) { /* Add this device as a replacement */ clear_bit(In_sync, &rdev->flags); set_bit(Replacement, &rdev->flags); raid1_add_conf(conf, rdev, repl_slot, true); err = 0; conf->fullsync = 1; }
print_conf(conf); return err;}
static int raid1_remove_disk(struct mddev *mddev, struct md_rdev *rdev){ struct r1conf *conf = mddev->private; int err = 0; int number = rdev->raid_disk; struct raid1_info *p = conf->mirrors + number;
if (unlikely(number >= conf->raid_disks)) goto abort;
if (rdev != p->rdev) { number += conf->raid_disks; p = conf->mirrors + number; }
print_conf(conf); if (rdev == p->rdev) { if (!raid1_remove_conf(conf, number)) { err = -EBUSY; goto abort; }
if (number < conf->raid_disks && conf->mirrors[conf->raid_disks + number].rdev) { /* We just removed a device that is being replaced. * Move down the replacement. We drain all IO before * doing this to avoid confusion. */ struct md_rdev *repl = conf->mirrors[conf->raid_disks + number].rdev; freeze_array(conf, 0); if (atomic_read(&repl->nr_pending)) { /* It means that some queued IO of retry_list * hold repl. Thus, we cannot set replacement * as NULL, avoiding rdev NULL pointer * dereference in sync_request_write and * handle_write_finished. */ err = -EBUSY; unfreeze_array(conf); goto abort; } clear_bit(Replacement, &repl->flags); WRITE_ONCE(p->rdev, repl); conf->mirrors[conf->raid_disks + number].rdev = NULL; unfreeze_array(conf); }
clear_bit(WantReplacement, &rdev->flags); err = md_integrity_register(mddev); }abort:
print_conf(conf); return err;}
static void end_sync_read(struct bio *bio){ struct r1bio *r1_bio = get_resync_r1bio(bio);
update_head_pos(r1_bio->read_disk, r1_bio);
/* * we have read a block, now it needs to be re-written, * or re-read if the read failed. * We don't do much here, just schedule handling by raid1d */ if (!bio->bi_status) set_bit(R1BIO_Uptodate, &r1_bio->state);
if (atomic_dec_and_test(&r1_bio->remaining)) reschedule_retry(r1_bio);}
static void abort_sync_write(struct mddev *mddev, struct r1bio *r1_bio){ sector_t sync_blocks = 0; sector_t s = r1_bio->sector; long sectors_to_go = r1_bio->sectors;
/* make sure these bits don't get cleared. */ do { md_bitmap_end_sync(mddev, s, &sync_blocks); s += sync_blocks; sectors_to_go -= sync_blocks; } while (sectors_to_go > 0);}
static void put_sync_write_buf(struct r1bio *r1_bio){ if (atomic_dec_and_test(&r1_bio->remaining)) { struct mddev *mddev = r1_bio->mddev; int s = r1_bio->sectors;
if (test_bit(R1BIO_MadeGood, &r1_bio->state) || test_bit(R1BIO_WriteError, &r1_bio->state)) reschedule_retry(r1_bio); else { put_buf(r1_bio); md_done_sync(mddev, s); } }}
static void end_sync_write(struct bio *bio){ struct r1bio *r1_bio = get_resync_r1bio(bio); struct mddev *mddev = r1_bio->mddev; struct r1conf *conf = mddev->private; struct md_rdev *rdev = conf->mirrors[find_bio_disk(r1_bio, bio)].rdev;
if (bio->bi_status) { abort_sync_write(mddev, r1_bio); set_bit(WriteErrorSeen, &rdev->flags); if (!test_and_set_bit(WantReplacement, &rdev->flags)) set_bit(MD_RECOVERY_NEEDED, & mddev->recovery); set_bit(R1BIO_WriteError, &r1_bio->state); } else if (rdev_has_badblock(rdev, r1_bio->sector, r1_bio->sectors) && !rdev_has_badblock(conf->mirrors[r1_bio->read_disk].rdev, r1_bio->sector, r1_bio->sectors)) { set_bit(R1BIO_MadeGood, &r1_bio->state); }
put_sync_write_buf(r1_bio);}
static int r1_sync_page_io(struct md_rdev *rdev, sector_t sector, int sectors, struct page *page, blk_opf_t rw){ if (sync_page_io(rdev, sector, sectors << 9, page, rw, false)) /* success */ return 1; if (rw == REQ_OP_WRITE) { set_bit(WriteErrorSeen, &rdev->flags); if (!test_and_set_bit(WantReplacement, &rdev->flags)) set_bit(MD_RECOVERY_NEEDED, & rdev->mddev->recovery); } /* need to record an error - either for the block or the device */ rdev_set_badblocks(rdev, sector, sectors, 0); return 0;}
static int fix_sync_read_error(struct r1bio *r1_bio){ /* Try some synchronous reads of other devices to get * good data, much like with normal read errors. Only * read into the pages we already have so we don't * need to re-issue the read request. * We don't need to freeze the array, because being in an * active sync request, there is no normal IO, and * no overlapping syncs. * We don't need to check is_badblock() again as we * made sure that anything with a bad block in range * will have bi_end_io clear. */ struct mddev *mddev = r1_bio->mddev; struct r1conf *conf = mddev->private; struct bio *bio = r1_bio->bios[r1_bio->read_disk]; struct page **pages = get_resync_pages(bio)->pages; sector_t sect = r1_bio->sector; int sectors = r1_bio->sectors; int idx = 0; struct md_rdev *rdev;
rdev = conf->mirrors[r1_bio->read_disk].rdev; if (test_bit(FailFast, &rdev->flags)) { /* Don't try recovering from here - just fail it * ... unless it is the last working device of course */ md_error(mddev, rdev); if (test_bit(Faulty, &rdev->flags)) /* Don't try to read from here, but make sure * put_buf does it's thing */ bio->bi_end_io = end_sync_write; }
while(sectors) { int s = sectors; int d = r1_bio->read_disk; int success = 0; int start;
if (s > (PAGE_SIZE>>9)) s = PAGE_SIZE >> 9; do { if (r1_bio->bios[d]->bi_end_io == end_sync_read) { /* No rcu protection needed here devices * can only be removed when no resync is * active, and resync is currently active */ rdev = conf->mirrors[d].rdev; if (sync_page_io(rdev, sect, s<<9, pages[idx], REQ_OP_READ, false)) { success = 1; break; } } d++; if (d == conf->raid_disks * 2) d = 0; } while (!success && d != r1_bio->read_disk);
if (!success) { int abort = 0; /* Cannot read from anywhere, this block is lost. * Record a bad block on each device. If that doesn't * work just disable and interrupt the recovery. * Don't fail devices as that won't really help. */ pr_crit_ratelimited("md/raid1:%s: %pg: unrecoverable I/O read error for block %llu\n", mdname(mddev), bio->bi_bdev, (unsigned long long)r1_bio->sector); for (d = 0; d < conf->raid_disks * 2; d++) { rdev = conf->mirrors[d].rdev; if (!rdev || test_bit(Faulty, &rdev->flags)) continue; if (!rdev_set_badblocks(rdev, sect, s, 0)) abort = 1; } if (abort) return 0;
/* Try next page */ sectors -= s; sect += s; idx++; continue; }
start = d; /* write it back and re-read */ while (d != r1_bio->read_disk) { if (d == 0) d = conf->raid_disks * 2; d--; if (r1_bio->bios[d]->bi_end_io != end_sync_read) continue; rdev = conf->mirrors[d].rdev; if (r1_sync_page_io(rdev, sect, s, pages[idx], REQ_OP_WRITE) == 0) { r1_bio->bios[d]->bi_end_io = NULL; rdev_dec_pending(rdev, mddev); } } d = start; while (d != r1_bio->read_disk) { if (d == 0) d = conf->raid_disks * 2; d--; if (r1_bio->bios[d]->bi_end_io != end_sync_read) continue; rdev = conf->mirrors[d].rdev; if (r1_sync_page_io(rdev, sect, s, pages[idx], REQ_OP_READ) != 0) atomic_add(s, &rdev->corrected_errors); } sectors -= s; sect += s; idx ++; } set_bit(R1BIO_Uptodate, &r1_bio->state); bio->bi_status = 0; return 1;}
static void process_checks(struct r1bio *r1_bio){ /* We have read all readable devices. If we haven't * got the block, then there is no hope left. * If we have, then we want to do a comparison * and skip the write if everything is the same. * If any blocks failed to read, then we need to * attempt an over-write */ struct mddev *mddev = r1_bio->mddev; struct r1conf *conf = mddev->private; int primary; int i; int vcnt;
/* Fix variable parts of all bios */ vcnt = (r1_bio->sectors + PAGE_SIZE / 512 - 1) >> (PAGE_SHIFT - 9); for (i = 0; i < conf->raid_disks * 2; i++) { blk_status_t status; struct bio *b = r1_bio->bios[i]; struct resync_pages *rp = get_resync_pages(b); if (b->bi_end_io != end_sync_read) continue; /* fixup the bio for reuse, but preserve errno */ status = b->bi_status; bio_reset(b, conf->mirrors[i].rdev->bdev, REQ_OP_READ); b->bi_status = status; b->bi_iter.bi_sector = r1_bio->sector + conf->mirrors[i].rdev->data_offset; b->bi_end_io = end_sync_read; rp->raid_bio = r1_bio; b->bi_private = rp;
/* initialize bvec table again */ md_bio_reset_resync_pages(b, rp, r1_bio->sectors << 9); } for (primary = 0; primary < conf->raid_disks * 2; primary++) if (r1_bio->bios[primary]->bi_end_io == end_sync_read && !r1_bio->bios[primary]->bi_status) { r1_bio->bios[primary]->bi_end_io = NULL; rdev_dec_pending(conf->mirrors[primary].rdev, mddev); break; } r1_bio->read_disk = primary; for (i = 0; i < conf->raid_disks * 2; i++) { int j = 0; struct bio *pbio = r1_bio->bios[primary]; struct bio *sbio = r1_bio->bios[i]; blk_status_t status = sbio->bi_status; struct page **ppages = get_resync_pages(pbio)->pages; struct page **spages = get_resync_pages(sbio)->pages; struct bio_vec *bi; int page_len[RESYNC_PAGES] = { 0 }; struct bvec_iter_all iter_all;
if (sbio->bi_end_io != end_sync_read) continue; /* Now we can 'fixup' the error value */ sbio->bi_status = 0;
bio_for_each_segment_all(bi, sbio, iter_all) page_len[j++] = bi->bv_len;
if (!status) { for (j = vcnt; j-- ; ) { if (memcmp(page_address(ppages[j]), page_address(spages[j]), page_len[j])) break; } } else j = 0; if (j >= 0) atomic64_add(r1_bio->sectors, &mddev->resync_mismatches); if (j < 0 || (test_bit(MD_RECOVERY_CHECK, &mddev->recovery) && !status)) { /* No need to write to this device. */ sbio->bi_end_io = NULL; rdev_dec_pending(conf->mirrors[i].rdev, mddev); continue; }
bio_copy_data(sbio, pbio); }}
static void sync_request_write(struct mddev *mddev, struct r1bio *r1_bio){ struct r1conf *conf = mddev->private; int i; int disks = conf->raid_disks * 2; struct bio *wbio;
if (!test_bit(R1BIO_Uptodate, &r1_bio->state)) { /* * ouch - failed to read all of that. * No need to fix read error for check/repair * because all member disks are read. */ if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) || !fix_sync_read_error(r1_bio)) { md_done_sync(mddev, r1_bio->sectors); md_sync_error(mddev); put_buf(r1_bio); return; } }
if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) process_checks(r1_bio);
/* * schedule writes */ atomic_set(&r1_bio->remaining, 1); for (i = 0; i < disks ; i++) { wbio = r1_bio->bios[i]; if (wbio->bi_end_io == NULL || (wbio->bi_end_io == end_sync_read && (i == r1_bio->read_disk || !test_bit(MD_RECOVERY_SYNC, &mddev->recovery)))) continue; if (test_bit(Faulty, &conf->mirrors[i].rdev->flags)) { abort_sync_write(mddev, r1_bio); continue; }
wbio->bi_opf = REQ_OP_WRITE; if (test_bit(FailFast, &conf->mirrors[i].rdev->flags)) wbio->bi_opf |= MD_FAILFAST;
wbio->bi_end_io = end_sync_write; atomic_inc(&r1_bio->remaining);
submit_bio_noacct(wbio); }
put_sync_write_buf(r1_bio);}
/* * This is a kernel thread which: * * 1. Retries failed read operations on working mirrors. * 2. Updates the raid superblock when problems encounter. * 3. Performs writes following reads for array synchronising. */
static void fix_read_error(struct r1conf *conf, struct r1bio *r1_bio){ sector_t sect = r1_bio->sector; int sectors = r1_bio->sectors; int read_disk = r1_bio->read_disk; struct mddev *mddev = conf->mddev; struct md_rdev *rdev = conf->mirrors[read_disk].rdev;
while(sectors) { int s = sectors; int d = read_disk; int success = 0; int start;
if (s > (PAGE_SIZE>>9)) s = PAGE_SIZE >> 9;
do { rdev = conf->mirrors[d].rdev; if (rdev && (test_bit(In_sync, &rdev->flags) || (!test_bit(Faulty, &rdev->flags) && rdev->recovery_offset >= sect + s)) && rdev_has_badblock(rdev, sect, s) == 0) { atomic_inc(&rdev->nr_pending); if (sync_page_io(rdev, sect, s<<9, conf->tmppage, REQ_OP_READ, false)) success = 1; rdev_dec_pending(rdev, mddev); if (success) break; }
d++; if (d == conf->raid_disks * 2) d = 0; } while (d != read_disk);
if (!success) { /* Cannot read from anywhere - mark it bad */ struct md_rdev *rdev = conf->mirrors[read_disk].rdev; rdev_set_badblocks(rdev, sect, s, 0); break; } /* write it back and re-read */ start = d; while (d != read_disk) { if (d==0) d = conf->raid_disks * 2; d--; rdev = conf->mirrors[d].rdev; if (rdev && !test_bit(Faulty, &rdev->flags)) { atomic_inc(&rdev->nr_pending); r1_sync_page_io(rdev, sect, s, conf->tmppage, REQ_OP_WRITE); rdev_dec_pending(rdev, mddev); } } d = start; while (d != read_disk) { if (d==0) d = conf->raid_disks * 2; d--; rdev = conf->mirrors[d].rdev; if (rdev && !test_bit(Faulty, &rdev->flags)) { atomic_inc(&rdev->nr_pending); if (r1_sync_page_io(rdev, sect, s, conf->tmppage, REQ_OP_READ)) { atomic_add(s, &rdev->corrected_errors); pr_info("md/raid1:%s: read error corrected (%d sectors at %llu on %pg)\n", mdname(mddev), s, (unsigned long long)(sect + rdev->data_offset), rdev->bdev); } rdev_dec_pending(rdev, mddev); } } sectors -= s; sect += s; }}
static void narrow_write_error(struct r1bio *r1_bio, int i){ struct mddev *mddev = r1_bio->mddev; struct r1conf *conf = mddev->private; struct md_rdev *rdev = conf->mirrors[i].rdev;
/* bio has the data to be written to device 'i' where * we just recently had a write error. * We repeatedly clone the bio and trim down to one block, * then try the write. Where the write fails we record * a bad block. * It is conceivable that the bio doesn't exactly align with * blocks. We must handle this somehow. * * We currently own a reference on the rdev. */
int block_sectors, lbs = bdev_logical_block_size(rdev->bdev) >> 9; sector_t sector; int sectors; int sect_to_write = r1_bio->sectors;
if (rdev->badblocks.shift < 0) block_sectors = lbs; else block_sectors = roundup(1 << rdev->badblocks.shift, lbs);
sector = r1_bio->sector; sectors = ((sector + block_sectors) & ~(sector_t)(block_sectors - 1)) - sector;
while (sect_to_write) { struct bio *wbio; if (sectors > sect_to_write) sectors = sect_to_write; /* Write at 'sector' for 'sectors'*/
if (test_bit(R1BIO_BehindIO, &r1_bio->state)) { wbio = bio_alloc_clone(rdev->bdev, r1_bio->behind_master_bio, GFP_NOIO, &mddev->bio_set); } else { wbio = bio_alloc_clone(rdev->bdev, r1_bio->master_bio, GFP_NOIO, &mddev->bio_set); }
wbio->bi_opf = REQ_OP_WRITE; wbio->bi_iter.bi_sector = r1_bio->sector; wbio->bi_iter.bi_size = r1_bio->sectors << 9;
bio_trim(wbio, sector - r1_bio->sector, sectors); wbio->bi_iter.bi_sector += rdev->data_offset;
if (submit_bio_wait(wbio) && !rdev_set_badblocks(rdev, sector, sectors, 0)) { /* * Badblocks set failed, disk marked Faulty. * No further operations needed. */ bio_put(wbio); break; }
bio_put(wbio); sect_to_write -= sectors; sector += sectors; sectors = block_sectors; }}
static void handle_sync_write_finished(struct r1conf *conf, struct r1bio *r1_bio){ int m; int s = r1_bio->sectors; for (m = 0; m < conf->raid_disks * 2 ; m++) { struct md_rdev *rdev = conf->mirrors[m].rdev; struct bio *bio = r1_bio->bios[m]; if (bio->bi_end_io == NULL) continue; if (!bio->bi_status && test_bit(R1BIO_MadeGood, &r1_bio->state)) rdev_clear_badblocks(rdev, r1_bio->sector, s, 0); if (bio->bi_status && test_bit(R1BIO_WriteError, &r1_bio->state)) rdev_set_badblocks(rdev, r1_bio->sector, s, 0); } put_buf(r1_bio); md_done_sync(conf->mddev, s);}
static void handle_write_finished(struct r1conf *conf, struct r1bio *r1_bio){ int m, idx; bool fail = false;
for (m = 0; m < conf->raid_disks * 2 ; m++) if (r1_bio->bios[m] == IO_MADE_GOOD) { struct md_rdev *rdev = conf->mirrors[m].rdev; rdev_clear_badblocks(rdev, r1_bio->sector, r1_bio->sectors, 0); rdev_dec_pending(rdev, conf->mddev); } else if (r1_bio->bios[m] != NULL) { /* This drive got a write error. We need to * narrow down and record precise write * errors. */ fail = true; narrow_write_error(r1_bio, m); rdev_dec_pending(conf->mirrors[m].rdev, conf->mddev); } if (fail) { spin_lock_irq(&conf->device_lock); list_add(&r1_bio->retry_list, &conf->bio_end_io_list); idx = sector_to_idx(r1_bio->sector); atomic_inc(&conf->nr_queued[idx]); spin_unlock_irq(&conf->device_lock); /* * In case freeze_array() is waiting for condition * get_unqueued_pending() == extra to be true. */ wake_up(&conf->wait_barrier); md_wakeup_thread(conf->mddev->thread); } else { if (test_bit(R1BIO_WriteError, &r1_bio->state)) close_write(r1_bio); raid_end_bio_io(r1_bio); }}
static void handle_read_error(struct r1conf *conf, struct r1bio *r1_bio){ struct md_rdev *rdev = conf->mirrors[r1_bio->read_disk].rdev; struct bio *bio = r1_bio->bios[r1_bio->read_disk]; struct mddev *mddev = conf->mddev; sector_t sector;
clear_bit(R1BIO_ReadError, &r1_bio->state);
bio_put(bio); r1_bio->bios[r1_bio->read_disk] = NULL;
/* * We got a read error. Maybe the drive is bad. Maybe just the block * and we can fix it. * * If allowed, freeze all other IO, and try reading the block from other * devices. If we find one, we re-write and check it that fixes the * read error. This is all done synchronously while the array is * frozen. */ if (mddev->ro) { r1_bio->bios[r1_bio->read_disk] = IO_BLOCKED; } else if (test_bit(FailFast, &rdev->flags)) { md_error(mddev, rdev); } else { freeze_array(conf, 1); if (exceed_read_errors(mddev, rdev)) r1_bio->bios[r1_bio->read_disk] = IO_BLOCKED; else fix_read_error(conf, r1_bio); unfreeze_array(conf); }
rdev_dec_pending(rdev, conf->mddev); sector = r1_bio->sector; bio = r1_bio->master_bio;
/* Reuse the old r1_bio so that the IO_BLOCKED settings are preserved */ r1_bio->state = 0; raid1_read_request(mddev, bio, r1_bio->sectors, r1_bio); allow_barrier(conf, sector);}
static void raid1d(struct md_thread *thread){ struct mddev *mddev = thread->mddev; struct r1bio *r1_bio; unsigned long flags; struct r1conf *conf = mddev->private; struct list_head *head = &conf->retry_list; struct blk_plug plug; int idx;
md_check_recovery(mddev);
if (!list_empty_careful(&conf->bio_end_io_list) && !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)) { LIST_HEAD(tmp); spin_lock_irqsave(&conf->device_lock, flags); if (!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)) list_splice_init(&conf->bio_end_io_list, &tmp); spin_unlock_irqrestore(&conf->device_lock, flags); while (!list_empty(&tmp)) { r1_bio = list_first_entry(&tmp, struct r1bio, retry_list); list_del(&r1_bio->retry_list); idx = sector_to_idx(r1_bio->sector); atomic_dec(&conf->nr_queued[idx]); if (test_bit(R1BIO_WriteError, &r1_bio->state)) close_write(r1_bio); raid_end_bio_io(r1_bio); } }
blk_start_plug(&plug); for (;;) {
flush_pending_writes(conf);
spin_lock_irqsave(&conf->device_lock, flags); if (list_empty(head)) { spin_unlock_irqrestore(&conf->device_lock, flags); break; } r1_bio = list_entry(head->prev, struct r1bio, retry_list); list_del(head->prev); idx = sector_to_idx(r1_bio->sector); atomic_dec(&conf->nr_queued[idx]); spin_unlock_irqrestore(&conf->device_lock, flags);
mddev = r1_bio->mddev; conf = mddev->private; if (test_bit(R1BIO_IsSync, &r1_bio->state)) { if (test_bit(R1BIO_MadeGood, &r1_bio->state) || test_bit(R1BIO_WriteError, &r1_bio->state)) handle_sync_write_finished(conf, r1_bio); else sync_request_write(mddev, r1_bio); } else if (test_bit(R1BIO_MadeGood, &r1_bio->state) || test_bit(R1BIO_WriteError, &r1_bio->state)) handle_write_finished(conf, r1_bio); else if (test_bit(R1BIO_ReadError, &r1_bio->state)) handle_read_error(conf, r1_bio); else WARN_ON_ONCE(1);
cond_resched(); if (mddev->sb_flags & ~(1<<MD_SB_CHANGE_PENDING)) md_check_recovery(mddev); } blk_finish_plug(&plug);}
static int init_resync(struct r1conf *conf){ int buffs;
buffs = RESYNC_WINDOW / RESYNC_BLOCK_SIZE; BUG_ON(mempool_initialized(&conf->r1buf_pool));
return mempool_init(&conf->r1buf_pool, buffs, r1buf_pool_alloc, r1buf_pool_free, conf);}
static struct r1bio *raid1_alloc_init_r1buf(struct r1conf *conf){ struct r1bio *r1bio = mempool_alloc(&conf->r1buf_pool, GFP_NOIO); struct resync_pages *rps; struct bio *bio; int i;
for (i = conf->raid_disks * 2; i--; ) { bio = r1bio->bios[i]; rps = bio->bi_private; bio_reset(bio, NULL, 0); bio->bi_private = rps; } r1bio->master_bio = NULL; return r1bio;}
/* * perform a "sync" on one "block" * * We need to make sure that no normal I/O request - particularly write * requests - conflict with active sync requests. * * This is achieved by tracking pending requests and a 'barrier' concept * that can be installed to exclude normal IO requests. */
static sector_t raid1_sync_request(struct mddev *mddev, sector_t sector_nr, sector_t max_sector, int *skipped){ struct r1conf *conf = mddev->private; struct r1bio *r1_bio; struct bio *bio; sector_t nr_sectors; int disk = -1; int i; int wonly = -1; int write_targets = 0, read_targets = 0; sector_t sync_blocks; bool still_degraded = false; int good_sectors = RESYNC_SECTORS; int min_bad = 0; /* number of sectors that are bad in all devices */ int idx = sector_to_idx(sector_nr); int page_idx = 0;
if (!mempool_initialized(&conf->r1buf_pool)) if (init_resync(conf)) return 0;
if (sector_nr >= max_sector) { /* If we aborted, we need to abort the * sync on the 'current' bitmap chunk (there will * only be one in raid1 resync. * We can find the current addess in mddev->curr_resync */ if (mddev->curr_resync < max_sector) /* aborted */ md_bitmap_end_sync(mddev, mddev->curr_resync, &sync_blocks); else /* completed sync */ conf->fullsync = 0;
if (md_bitmap_enabled(mddev, false)) mddev->bitmap_ops->close_sync(mddev); close_sync(conf);
if (mddev_is_clustered(mddev)) { conf->cluster_sync_low = 0; conf->cluster_sync_high = 0; } return 0; }
if (mddev->bitmap == NULL && mddev->resync_offset == MaxSector && !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) && conf->fullsync == 0) { *skipped = 1; return max_sector - sector_nr; } /* before building a request, check if we can skip these blocks.. * This call the bitmap_start_sync doesn't actually record anything */ if (!md_bitmap_start_sync(mddev, sector_nr, &sync_blocks, true) && !conf->fullsync && !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) { /* We can skip this block, and probably several more */ *skipped = 1; return sync_blocks; }
/* * If there is non-resync activity waiting for a turn, then let it * though before starting on this new sync request. */ if (atomic_read(&conf->nr_waiting[idx])) schedule_timeout_uninterruptible(1);
/* we are incrementing sector_nr below. To be safe, we check against * sector_nr + two times RESYNC_SECTORS */ if (md_bitmap_enabled(mddev, false)) mddev->bitmap_ops->cond_end_sync(mddev, sector_nr, mddev_is_clustered(mddev) && (sector_nr + 2 * RESYNC_SECTORS > conf->cluster_sync_high));
if (raise_barrier(conf, sector_nr)) return 0;
r1_bio = raid1_alloc_init_r1buf(conf);
/* * If we get a correctably read error during resync or recovery, * we might want to read from a different device. So we * flag all drives that could conceivably be read from for READ, * and any others (which will be non-In_sync devices) for WRITE. * If a read fails, we try reading from something else for which READ * is OK. */
r1_bio->mddev = mddev; r1_bio->sector = sector_nr; r1_bio->state = 0; set_bit(R1BIO_IsSync, &r1_bio->state); /* make sure good_sectors won't go across barrier unit boundary */ good_sectors = align_to_barrier_unit_end(sector_nr, good_sectors);
for (i = 0; i < conf->raid_disks * 2; i++) { struct md_rdev *rdev; bio = r1_bio->bios[i];
rdev = conf->mirrors[i].rdev; if (rdev == NULL || test_bit(Faulty, &rdev->flags)) { if (i < conf->raid_disks) still_degraded = true; } else if (!test_bit(In_sync, &rdev->flags)) { bio->bi_opf = REQ_OP_WRITE; bio->bi_end_io = end_sync_write; write_targets ++; } else { /* may need to read from here */ sector_t first_bad = MaxSector; sector_t bad_sectors;
if (is_badblock(rdev, sector_nr, good_sectors, &first_bad, &bad_sectors)) { if (first_bad > sector_nr) good_sectors = first_bad - sector_nr; else { bad_sectors -= (sector_nr - first_bad); if (min_bad == 0 || min_bad > bad_sectors) min_bad = bad_sectors; } } if (sector_nr < first_bad) { if (test_bit(WriteMostly, &rdev->flags)) { if (wonly < 0) wonly = i; } else { if (disk < 0) disk = i; } bio->bi_opf = REQ_OP_READ; bio->bi_end_io = end_sync_read; read_targets++; } else if (!test_bit(WriteErrorSeen, &rdev->flags) && test_bit(MD_RECOVERY_SYNC, &mddev->recovery) && !test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) { /* * The device is suitable for reading (InSync), * but has bad block(s) here. Let's try to correct them, * if we are doing resync or repair. Otherwise, leave * this device alone for this sync request. */ bio->bi_opf = REQ_OP_WRITE; bio->bi_end_io = end_sync_write; write_targets++; } } if (rdev && bio->bi_end_io) { atomic_inc(&rdev->nr_pending); bio->bi_iter.bi_sector = sector_nr + rdev->data_offset; bio_set_dev(bio, rdev->bdev); if (test_bit(FailFast, &rdev->flags)) bio->bi_opf |= MD_FAILFAST; } } if (disk < 0) disk = wonly; r1_bio->read_disk = disk;
if (read_targets == 0 && min_bad > 0) { /* These sectors are bad on all InSync devices, so we * need to mark them bad on all write targets */ int ok = 1; for (i = 0 ; i < conf->raid_disks * 2 ; i++) if (r1_bio->bios[i]->bi_end_io == end_sync_write) { struct md_rdev *rdev = conf->mirrors[i].rdev; ok = rdev_set_badblocks(rdev, sector_nr, min_bad, 0 ) && ok; } set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags); *skipped = 1; put_buf(r1_bio);
if (!ok) /* Cannot record the badblocks, md_error has set INTR, * abort the resync. */ return 0; else return min_bad;
} if (min_bad > 0 && min_bad < good_sectors) { /* only resync enough to reach the next bad->good * transition */ good_sectors = min_bad; }
if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) && read_targets > 0) /* extra read targets are also write targets */ write_targets += read_targets-1;
if (write_targets == 0 || read_targets == 0) { /* There is nowhere to write, so all non-sync * drives must be failed - so we are finished */ sector_t rv; if (min_bad > 0) max_sector = sector_nr + min_bad; rv = max_sector - sector_nr; *skipped = 1; put_buf(r1_bio); return rv; }
if (max_sector > mddev->resync_max) max_sector = mddev->resync_max; /* Don't do IO beyond here */ if (max_sector > sector_nr + good_sectors) max_sector = sector_nr + good_sectors; nr_sectors = 0; sync_blocks = 0; do { struct page *page; int len = PAGE_SIZE; if (sector_nr + (len>>9) > max_sector) len = (max_sector - sector_nr) << 9; if (len == 0) break; if (sync_blocks == 0) { if (!md_bitmap_start_sync(mddev, sector_nr, &sync_blocks, still_degraded) && !conf->fullsync && !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) break; if ((len >> 9) > sync_blocks) len = sync_blocks<<9; }
for (i = 0 ; i < conf->raid_disks * 2; i++) { struct resync_pages *rp;
bio = r1_bio->bios[i]; rp = get_resync_pages(bio); if (bio->bi_end_io) { page = resync_fetch_page(rp, page_idx);
/* * won't fail because the vec table is big * enough to hold all these pages */ __bio_add_page(bio, page, len, 0); } } nr_sectors += len>>9; sector_nr += len>>9; sync_blocks -= (len>>9); } while (++page_idx < RESYNC_PAGES);
r1_bio->sectors = nr_sectors;
if (mddev_is_clustered(mddev) && conf->cluster_sync_high < sector_nr + nr_sectors) { conf->cluster_sync_low = mddev->curr_resync_completed; conf->cluster_sync_high = conf->cluster_sync_low + CLUSTER_RESYNC_WINDOW_SECTORS; /* Send resync message */ mddev->cluster_ops->resync_info_update(mddev, conf->cluster_sync_low, conf->cluster_sync_high); }
/* For a user-requested sync, we read all readable devices and do a * compare */ if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) { atomic_set(&r1_bio->remaining, read_targets); for (i = 0; i < conf->raid_disks * 2 && read_targets; i++) { bio = r1_bio->bios[i]; if (bio->bi_end_io == end_sync_read) { read_targets--; if (read_targets == 1) bio->bi_opf &= ~MD_FAILFAST; submit_bio_noacct(bio); } } } else { atomic_set(&r1_bio->remaining, 1); bio = r1_bio->bios[r1_bio->read_disk]; if (read_targets == 1) bio->bi_opf &= ~MD_FAILFAST; submit_bio_noacct(bio); } return nr_sectors;}
static sector_t raid1_size(struct mddev *mddev, sector_t sectors, int raid_disks){ if (sectors) return sectors;
return mddev->dev_sectors;}
static struct r1conf *setup_conf(struct mddev *mddev){ struct r1conf *conf; int i; struct raid1_info *disk; struct md_rdev *rdev; size_t r1bio_size; int err = -ENOMEM;
conf = kzalloc_obj(struct r1conf); if (!conf) goto abort;
conf->nr_pending = kzalloc_objs(atomic_t, BARRIER_BUCKETS_NR); if (!conf->nr_pending) goto abort;
conf->nr_waiting = kzalloc_objs(atomic_t, BARRIER_BUCKETS_NR); if (!conf->nr_waiting) goto abort;
conf->nr_queued = kzalloc_objs(atomic_t, BARRIER_BUCKETS_NR); if (!conf->nr_queued) goto abort;
conf->barrier = kzalloc_objs(atomic_t, BARRIER_BUCKETS_NR); if (!conf->barrier) goto abort;
conf->mirrors = kzalloc(array3_size(sizeof(struct raid1_info), mddev->raid_disks, 2), GFP_KERNEL); if (!conf->mirrors) goto abort;
conf->tmppage = alloc_page(GFP_KERNEL); if (!conf->tmppage) goto abort;
r1bio_size = offsetof(struct r1bio, bios[mddev->raid_disks * 2]); conf->r1bio_pool = mempool_create_kmalloc_pool(NR_RAID_BIOS, r1bio_size); if (!conf->r1bio_pool) goto abort;
err = bioset_init(&conf->bio_split, BIO_POOL_SIZE, 0, 0); if (err) goto abort;
err = -EINVAL; spin_lock_init(&conf->device_lock); conf->raid_disks = mddev->raid_disks; rdev_for_each(rdev, mddev) { int disk_idx = rdev->raid_disk;
if (disk_idx >= conf->raid_disks || disk_idx < 0) continue;
if (!raid1_add_conf(conf, rdev, disk_idx, test_bit(Replacement, &rdev->flags))) goto abort; } conf->mddev = mddev; INIT_LIST_HEAD(&conf->retry_list); INIT_LIST_HEAD(&conf->bio_end_io_list);
spin_lock_init(&conf->resync_lock); init_waitqueue_head(&conf->wait_barrier);
bio_list_init(&conf->pending_bio_list);
err = -EIO; for (i = 0; i < conf->raid_disks * 2; i++) {
disk = conf->mirrors + i;
if (i < conf->raid_disks && disk[conf->raid_disks].rdev) { /* This slot has a replacement. */ if (!disk->rdev) { /* No original, just make the replacement * a recovering spare */ disk->rdev = disk[conf->raid_disks].rdev; disk[conf->raid_disks].rdev = NULL; } else if (!test_bit(In_sync, &disk->rdev->flags)) /* Original is not in_sync - bad */ goto abort; }
if (!disk->rdev || !test_bit(In_sync, &disk->rdev->flags)) { disk->head_position = 0; if (disk->rdev && (disk->rdev->saved_raid_disk < 0)) conf->fullsync = 1; } }
err = -ENOMEM; rcu_assign_pointer(conf->thread, md_register_thread(raid1d, mddev, "raid1")); if (!conf->thread) goto abort;
return conf;
abort: if (conf) { mempool_destroy(conf->r1bio_pool); kfree(conf->mirrors); safe_put_page(conf->tmppage); kfree(conf->nr_pending); kfree(conf->nr_waiting); kfree(conf->nr_queued); kfree(conf->barrier); bioset_exit(&conf->bio_split); kfree(conf); } return ERR_PTR(err);}
static int raid1_set_limits(struct mddev *mddev){ struct queue_limits lim; int err;
md_init_stacking_limits(&lim); lim.max_write_zeroes_sectors = 0; lim.max_hw_wzeroes_unmap_sectors = 0; lim.chunk_sectors = BARRIER_UNIT_SECTOR_SIZE; lim.logical_block_size = mddev->logical_block_size; lim.features |= BLK_FEAT_ATOMIC_WRITES; lim.features |= BLK_FEAT_PCI_P2PDMA; err = mddev_stack_rdev_limits(mddev, &lim, MDDEV_STACK_INTEGRITY); if (err) return err; return queue_limits_set(mddev->gendisk->queue, &lim);}
static int raid1_run(struct mddev *mddev){ struct r1conf *conf; int i; int ret;
if (mddev->level != 1) { pr_warn("md/raid1:%s: raid level not set to mirroring (%d)\n", mdname(mddev), mddev->level); return -EIO; } if (mddev->reshape_position != MaxSector) { pr_warn("md/raid1:%s: reshape_position set but not supported\n", mdname(mddev)); return -EIO; }
/* * copy the already verified devices into our private RAID1 * bookkeeping area. [whatever we allocate in run(), * should be freed in raid1_free()] */ if (mddev->private == NULL) conf = setup_conf(mddev); else conf = mddev->private;
if (IS_ERR(conf)) return PTR_ERR(conf);
if (!mddev_is_dm(mddev)) { ret = raid1_set_limits(mddev); if (ret) { md_unregister_thread(mddev, &conf->thread); if (!mddev->private) raid1_free(mddev, conf); return ret; } }
mddev->degraded = 0; for (i = 0; i < conf->raid_disks; i++) if (conf->mirrors[i].rdev == NULL || !test_bit(In_sync, &conf->mirrors[i].rdev->flags) || test_bit(Faulty, &conf->mirrors[i].rdev->flags)) mddev->degraded++; /* * RAID1 needs at least one disk in active */ if (conf->raid_disks - mddev->degraded < 1) { md_unregister_thread(mddev, &conf->thread); if (!mddev->private) raid1_free(mddev, conf); return -EINVAL; }
if (conf->raid_disks - mddev->degraded == 1) mddev->resync_offset = MaxSector;
if (mddev->resync_offset != MaxSector) pr_info("md/raid1:%s: not clean -- starting background reconstruction\n", mdname(mddev)); pr_info("md/raid1:%s: active with %d out of %d mirrors\n", mdname(mddev), mddev->raid_disks - mddev->degraded, mddev->raid_disks);
/* * Ok, everything is just fine now */ rcu_assign_pointer(mddev->thread, conf->thread); rcu_assign_pointer(conf->thread, NULL); mddev->private = conf; set_bit(MD_FAILFAST_SUPPORTED, &mddev->flags);
md_set_array_sectors(mddev, raid1_size(mddev, 0, 0));
ret = md_integrity_register(mddev); if (ret) md_unregister_thread(mddev, &mddev->thread); return ret;}
static void raid1_free(struct mddev *mddev, void *priv){ struct r1conf *conf = priv;
mempool_destroy(conf->r1bio_pool); kfree(conf->mirrors); safe_put_page(conf->tmppage); kfree(conf->nr_pending); kfree(conf->nr_waiting); kfree(conf->nr_queued); kfree(conf->barrier); bioset_exit(&conf->bio_split); kfree(conf);}
static int raid1_resize(struct mddev *mddev, sector_t sectors){ /* no resync is happening, and there is enough space * on all devices, so we can resize. * We need to make sure resync covers any new space. * If the array is shrinking we should possibly wait until * any io in the removed space completes, but it hardly seems * worth it. */ sector_t newsize = raid1_size(mddev, sectors, 0);
if (mddev->external_size && mddev->array_sectors > newsize) return -EINVAL;
if (md_bitmap_enabled(mddev, false)) { int ret = mddev->bitmap_ops->resize(mddev, newsize, 0);
if (ret) return ret; }
md_set_array_sectors(mddev, newsize); if (sectors > mddev->dev_sectors && mddev->resync_offset > mddev->dev_sectors) { mddev->resync_offset = mddev->dev_sectors; set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); } mddev->dev_sectors = sectors; mddev->resync_max_sectors = sectors; return 0;}
static int raid1_reshape(struct mddev *mddev){ /* We need to: * 1/ resize the r1bio_pool * 2/ resize conf->mirrors * * We allocate a new r1bio_pool if we can. * Then raise a device barrier and wait until all IO stops. * Then resize conf->mirrors and swap in the new r1bio pool. * * At the same time, we "pack" the devices so that all the missing * devices have the higher raid_disk numbers. */ mempool_t *newpool, *oldpool; size_t new_r1bio_size; struct raid1_info *newmirrors; struct r1conf *conf = mddev->private; int cnt, raid_disks; unsigned long flags; int d, d2;
/* Cannot change chunk_size, layout, or level */ if (mddev->chunk_sectors != mddev->new_chunk_sectors || mddev->layout != mddev->new_layout || mddev->level != mddev->new_level) { mddev->new_chunk_sectors = mddev->chunk_sectors; mddev->new_layout = mddev->layout; mddev->new_level = mddev->level; return -EINVAL; }
if (!mddev_is_clustered(mddev)) md_allow_write(mddev);
raid_disks = mddev->raid_disks + mddev->delta_disks;
if (raid_disks < conf->raid_disks) { cnt=0; for (d= 0; d < conf->raid_disks; d++) if (conf->mirrors[d].rdev) cnt++; if (cnt > raid_disks) return -EBUSY; }
new_r1bio_size = offsetof(struct r1bio, bios[raid_disks * 2]); newpool = mempool_create_kmalloc_pool(NR_RAID_BIOS, new_r1bio_size); if (!newpool) { return -ENOMEM; } newmirrors = kzalloc(array3_size(sizeof(struct raid1_info), raid_disks, 2), GFP_KERNEL); if (!newmirrors) { mempool_destroy(newpool); return -ENOMEM; }
freeze_array(conf, 0);
/* ok, everything is stopped */ oldpool = conf->r1bio_pool; conf->r1bio_pool = newpool;
for (d = d2 = 0; d < conf->raid_disks; d++) { struct md_rdev *rdev = conf->mirrors[d].rdev; if (rdev && rdev->raid_disk != d2) { sysfs_unlink_rdev(mddev, rdev); rdev->raid_disk = d2; sysfs_unlink_rdev(mddev, rdev); if (sysfs_link_rdev(mddev, rdev)) pr_warn("md/raid1:%s: cannot register rd%d\n", mdname(mddev), rdev->raid_disk); } if (rdev) newmirrors[d2++].rdev = rdev; } kfree(conf->mirrors); conf->mirrors = newmirrors;
spin_lock_irqsave(&conf->device_lock, flags); mddev->degraded += (raid_disks - conf->raid_disks); spin_unlock_irqrestore(&conf->device_lock, flags); conf->raid_disks = mddev->raid_disks = raid_disks; mddev->delta_disks = 0;
unfreeze_array(conf);
set_bit(MD_RECOVERY_RECOVER, &mddev->recovery); set_bit(MD_RECOVERY_NEEDED, &mddev->recovery); md_wakeup_thread(mddev->thread);
mempool_destroy(oldpool); return 0;}
static void raid1_quiesce(struct mddev *mddev, int quiesce){ struct r1conf *conf = mddev->private;
if (quiesce) freeze_array(conf, 0); else unfreeze_array(conf);}
static void *raid1_takeover(struct mddev *mddev){ /* raid1 can take over: * raid5 with 2 devices, any layout or chunk size */ if (mddev->level == 5 && mddev->raid_disks == 2) { struct r1conf *conf; mddev->new_level = 1; mddev->new_layout = 0; mddev->new_chunk_sectors = 0; conf = setup_conf(mddev); if (!IS_ERR(conf)) { mddev_clear_unsupported_flags(mddev, UNSUPPORTED_MDDEV_FLAGS); } return conf; } return ERR_PTR(-EINVAL);}
static struct md_personality raid1_personality ={ .head = { .type = MD_PERSONALITY, .id = ID_RAID1, .name = "raid1", .owner = THIS_MODULE, },
.make_request = raid1_make_request, .run = raid1_run, .free = raid1_free, .status = raid1_status, .error_handler = raid1_error, .hot_add_disk = raid1_add_disk, .hot_remove_disk= raid1_remove_disk, .spare_active = raid1_spare_active, .sync_request = raid1_sync_request, .resize = raid1_resize, .size = raid1_size, .check_reshape = raid1_reshape, .quiesce = raid1_quiesce, .takeover = raid1_takeover,};
static int __init raid1_init(void){ return register_md_submodule(&raid1_personality.head);}
static void __exit raid1_exit(void){ unregister_md_submodule(&raid1_personality.head);}
module_init(raid1_init);module_exit(raid1_exit);MODULE_LICENSE("GPL");MODULE_DESCRIPTION("RAID1 (mirroring) personality for MD");MODULE_ALIAS("md-personality-3"); /* RAID1 */MODULE_ALIAS("md-raid1");MODULE_ALIAS("md-level-1");