md.c 258 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508450945104511451245134514451545164517451845194520452145224523452445254526452745284529453045314532453345344535453645374538453945404541454245434544454545464547454845494550455145524553455445554556455745584559456045614562456345644565456645674568456945704571457245734574457545764577457845794580458145824583458445854586458745884589459045914592459345944595459645974598459946004601460246034604460546064607460846094610461146124613461446154616461746184619462046214622462346244625462646274628462946304631463246334634463546364637463846394640464146424643464446454646464746484649465046514652465346544655465646574658465946604661466246634664466546664667466846694670467146724673467446754676467746784679468046814682468346844685468646874688468946904691469246934694469546964697469846994700470147024703470447054706470747084709471047114712471347144715471647174718471947204721472247234724472547264727472847294730473147324733473447354736473747384739474047414742474347444745474647474748474947504751475247534754475547564757475847594760476147624763476447654766476747684769477047714772477347744775477647774778477947804781478247834784478547864787478847894790479147924793479447954796479747984799480048014802480348044805480648074808480948104811481248134814481548164817481848194820482148224823482448254826482748284829483048314832483348344835483648374838483948404841484248434844484548464847484848494850485148524853485448554856485748584859486048614862486348644865486648674868486948704871487248734874487548764877487848794880488148824883488448854886488748884889489048914892489348944895489648974898489949004901490249034904490549064907490849094910491149124913491449154916491749184919492049214922492349244925492649274928492949304931493249334934493549364937493849394940494149424943494449454946494749484949495049514952495349544955495649574958495949604961496249634964496549664967496849694970497149724973497449754976497749784979498049814982498349844985498649874988498949904991499249934994499549964997499849995000500150025003500450055006500750085009501050115012501350145015501650175018501950205021502250235024502550265027502850295030503150325033503450355036503750385039504050415042504350445045504650475048504950505051505250535054505550565057505850595060506150625063506450655066506750685069507050715072507350745075507650775078507950805081508250835084508550865087508850895090509150925093509450955096509750985099510051015102510351045105510651075108510951105111511251135114511551165117511851195120512151225123512451255126512751285129513051315132513351345135513651375138513951405141514251435144514551465147514851495150515151525153515451555156515751585159516051615162516351645165516651675168516951705171517251735174517551765177517851795180518151825183518451855186518751885189519051915192519351945195519651975198519952005201520252035204520552065207520852095210521152125213521452155216521752185219522052215222522352245225522652275228522952305231523252335234523552365237523852395240524152425243524452455246524752485249525052515252525352545255525652575258525952605261526252635264526552665267526852695270527152725273527452755276527752785279528052815282528352845285528652875288528952905291529252935294529552965297529852995300530153025303530453055306530753085309531053115312531353145315531653175318531953205321532253235324532553265327532853295330533153325333533453355336533753385339534053415342534353445345534653475348534953505351535253535354535553565357535853595360536153625363536453655366536753685369537053715372537353745375537653775378537953805381538253835384538553865387538853895390539153925393539453955396539753985399540054015402540354045405540654075408540954105411541254135414541554165417541854195420542154225423542454255426542754285429543054315432543354345435543654375438543954405441544254435444544554465447544854495450545154525453545454555456545754585459546054615462546354645465546654675468546954705471547254735474547554765477547854795480548154825483548454855486548754885489549054915492549354945495549654975498549955005501550255035504550555065507550855095510551155125513551455155516551755185519552055215522552355245525552655275528552955305531553255335534553555365537553855395540554155425543554455455546554755485549555055515552555355545555555655575558555955605561556255635564556555665567556855695570557155725573557455755576557755785579558055815582558355845585558655875588558955905591559255935594559555965597559855995600560156025603560456055606560756085609561056115612561356145615561656175618561956205621562256235624562556265627562856295630563156325633563456355636563756385639564056415642564356445645564656475648564956505651565256535654565556565657565856595660566156625663566456655666566756685669567056715672567356745675567656775678567956805681568256835684568556865687568856895690569156925693569456955696569756985699570057015702570357045705570657075708570957105711571257135714571557165717571857195720572157225723572457255726572757285729573057315732573357345735573657375738573957405741574257435744574557465747574857495750575157525753575457555756575757585759576057615762576357645765576657675768576957705771577257735774577557765777577857795780578157825783578457855786578757885789579057915792579357945795579657975798579958005801580258035804580558065807580858095810581158125813581458155816581758185819582058215822582358245825582658275828582958305831583258335834583558365837583858395840584158425843584458455846584758485849585058515852585358545855585658575858585958605861586258635864586558665867586858695870587158725873587458755876587758785879588058815882588358845885588658875888588958905891589258935894589558965897589858995900590159025903590459055906590759085909591059115912591359145915591659175918591959205921592259235924592559265927592859295930593159325933593459355936593759385939594059415942594359445945594659475948594959505951595259535954595559565957595859595960596159625963596459655966596759685969597059715972597359745975597659775978597959805981598259835984598559865987598859895990599159925993599459955996599759985999600060016002600360046005600660076008600960106011601260136014601560166017601860196020602160226023602460256026602760286029603060316032603360346035603660376038603960406041604260436044604560466047604860496050605160526053605460556056605760586059606060616062606360646065606660676068606960706071607260736074607560766077607860796080608160826083608460856086608760886089609060916092609360946095609660976098609961006101610261036104610561066107610861096110611161126113611461156116611761186119612061216122612361246125612661276128612961306131613261336134613561366137613861396140614161426143614461456146614761486149615061516152615361546155615661576158615961606161616261636164616561666167616861696170617161726173617461756176617761786179618061816182618361846185618661876188618961906191619261936194619561966197619861996200620162026203620462056206620762086209621062116212621362146215621662176218621962206221622262236224622562266227622862296230623162326233623462356236623762386239624062416242624362446245624662476248624962506251625262536254625562566257625862596260626162626263626462656266626762686269627062716272627362746275627662776278627962806281628262836284628562866287628862896290629162926293629462956296629762986299630063016302630363046305630663076308630963106311631263136314631563166317631863196320632163226323632463256326632763286329633063316332633363346335633663376338633963406341634263436344634563466347634863496350635163526353635463556356635763586359636063616362636363646365636663676368636963706371637263736374637563766377637863796380638163826383638463856386638763886389639063916392639363946395639663976398639964006401640264036404640564066407640864096410641164126413641464156416641764186419642064216422642364246425642664276428642964306431643264336434643564366437643864396440644164426443644464456446644764486449645064516452645364546455645664576458645964606461646264636464646564666467646864696470647164726473647464756476647764786479648064816482648364846485648664876488648964906491649264936494649564966497649864996500650165026503650465056506650765086509651065116512651365146515651665176518651965206521652265236524652565266527652865296530653165326533653465356536653765386539654065416542654365446545654665476548654965506551655265536554655565566557655865596560656165626563656465656566656765686569657065716572657365746575657665776578657965806581658265836584658565866587658865896590659165926593659465956596659765986599660066016602660366046605660666076608660966106611661266136614661566166617661866196620662166226623662466256626662766286629663066316632663366346635663666376638663966406641664266436644664566466647664866496650665166526653665466556656665766586659666066616662666366646665666666676668666966706671667266736674667566766677667866796680668166826683668466856686668766886689669066916692669366946695669666976698669967006701670267036704670567066707670867096710671167126713671467156716671767186719672067216722672367246725672667276728672967306731673267336734673567366737673867396740674167426743674467456746674767486749675067516752675367546755675667576758675967606761676267636764676567666767676867696770677167726773677467756776677767786779678067816782678367846785678667876788678967906791679267936794679567966797679867996800680168026803680468056806680768086809681068116812681368146815681668176818681968206821682268236824682568266827682868296830683168326833683468356836683768386839684068416842684368446845684668476848684968506851685268536854685568566857685868596860686168626863686468656866686768686869687068716872687368746875687668776878687968806881688268836884688568866887688868896890689168926893689468956896689768986899690069016902690369046905690669076908690969106911691269136914691569166917691869196920692169226923692469256926692769286929693069316932693369346935693669376938693969406941694269436944694569466947694869496950695169526953695469556956695769586959696069616962696369646965696669676968696969706971697269736974697569766977697869796980698169826983698469856986698769886989699069916992699369946995699669976998699970007001700270037004700570067007700870097010701170127013701470157016701770187019702070217022702370247025702670277028702970307031703270337034703570367037703870397040704170427043704470457046704770487049705070517052705370547055705670577058705970607061706270637064706570667067706870697070707170727073707470757076707770787079708070817082708370847085708670877088708970907091709270937094709570967097709870997100710171027103710471057106710771087109711071117112711371147115711671177118711971207121712271237124712571267127712871297130713171327133713471357136713771387139714071417142714371447145714671477148714971507151715271537154715571567157715871597160716171627163716471657166716771687169717071717172717371747175717671777178717971807181718271837184718571867187718871897190719171927193719471957196719771987199720072017202720372047205720672077208720972107211721272137214721572167217721872197220722172227223722472257226722772287229723072317232723372347235723672377238723972407241724272437244724572467247724872497250725172527253725472557256725772587259726072617262726372647265726672677268726972707271727272737274727572767277727872797280728172827283728472857286728772887289729072917292729372947295729672977298729973007301730273037304730573067307730873097310731173127313731473157316731773187319732073217322732373247325732673277328732973307331733273337334733573367337733873397340734173427343734473457346734773487349735073517352735373547355735673577358735973607361736273637364736573667367736873697370737173727373737473757376737773787379738073817382738373847385738673877388738973907391739273937394739573967397739873997400740174027403740474057406740774087409741074117412741374147415741674177418741974207421742274237424742574267427742874297430743174327433743474357436743774387439744074417442744374447445744674477448744974507451745274537454745574567457745874597460746174627463746474657466746774687469747074717472747374747475747674777478747974807481748274837484748574867487748874897490749174927493749474957496749774987499750075017502750375047505750675077508750975107511751275137514751575167517751875197520752175227523752475257526752775287529753075317532753375347535753675377538753975407541754275437544754575467547754875497550755175527553755475557556755775587559756075617562756375647565756675677568756975707571757275737574757575767577757875797580758175827583758475857586758775887589759075917592759375947595759675977598759976007601760276037604760576067607760876097610761176127613761476157616761776187619762076217622762376247625762676277628762976307631763276337634763576367637763876397640764176427643764476457646764776487649765076517652765376547655765676577658765976607661766276637664766576667667766876697670767176727673767476757676767776787679768076817682768376847685768676877688768976907691769276937694769576967697769876997700770177027703770477057706770777087709771077117712771377147715771677177718771977207721772277237724772577267727772877297730773177327733773477357736773777387739774077417742774377447745774677477748774977507751775277537754775577567757775877597760776177627763776477657766776777687769777077717772777377747775777677777778777977807781778277837784778577867787778877897790779177927793779477957796779777987799780078017802780378047805780678077808780978107811781278137814781578167817781878197820782178227823782478257826782778287829783078317832783378347835783678377838783978407841784278437844784578467847784878497850785178527853785478557856785778587859786078617862786378647865786678677868786978707871787278737874787578767877787878797880788178827883788478857886788778887889789078917892789378947895789678977898789979007901790279037904790579067907790879097910791179127913791479157916791779187919792079217922792379247925792679277928792979307931793279337934793579367937793879397940794179427943794479457946794779487949795079517952795379547955795679577958795979607961796279637964796579667967796879697970797179727973797479757976797779787979798079817982798379847985798679877988798979907991799279937994799579967997799879998000800180028003800480058006800780088009801080118012801380148015801680178018801980208021802280238024802580268027802880298030803180328033803480358036803780388039804080418042804380448045804680478048804980508051805280538054805580568057805880598060806180628063806480658066806780688069807080718072807380748075807680778078807980808081808280838084808580868087808880898090809180928093809480958096809780988099810081018102810381048105810681078108810981108111811281138114811581168117811881198120812181228123812481258126812781288129813081318132813381348135813681378138813981408141814281438144814581468147814881498150815181528153815481558156815781588159816081618162816381648165816681678168816981708171817281738174817581768177817881798180818181828183818481858186818781888189819081918192819381948195819681978198819982008201820282038204820582068207820882098210821182128213821482158216821782188219822082218222822382248225822682278228822982308231823282338234823582368237823882398240824182428243824482458246824782488249825082518252825382548255825682578258825982608261826282638264826582668267826882698270827182728273827482758276827782788279828082818282828382848285828682878288828982908291829282938294829582968297829882998300830183028303830483058306830783088309831083118312831383148315831683178318831983208321832283238324832583268327832883298330833183328333833483358336833783388339834083418342834383448345834683478348834983508351835283538354835583568357835883598360836183628363836483658366836783688369837083718372837383748375837683778378837983808381838283838384838583868387838883898390839183928393839483958396839783988399840084018402840384048405840684078408840984108411841284138414841584168417841884198420842184228423842484258426842784288429843084318432843384348435843684378438843984408441844284438444844584468447844884498450845184528453845484558456845784588459846084618462846384648465846684678468846984708471847284738474847584768477847884798480848184828483848484858486848784888489849084918492849384948495849684978498849985008501850285038504850585068507850885098510851185128513851485158516851785188519852085218522852385248525852685278528852985308531853285338534853585368537853885398540854185428543854485458546854785488549855085518552855385548555855685578558855985608561856285638564856585668567856885698570857185728573857485758576857785788579858085818582858385848585858685878588858985908591859285938594859585968597859885998600860186028603860486058606860786088609861086118612861386148615861686178618861986208621862286238624862586268627862886298630863186328633863486358636863786388639864086418642864386448645864686478648864986508651865286538654865586568657865886598660866186628663866486658666866786688669867086718672867386748675867686778678867986808681868286838684868586868687868886898690869186928693869486958696869786988699870087018702870387048705870687078708870987108711871287138714871587168717871887198720872187228723872487258726872787288729873087318732873387348735873687378738873987408741874287438744874587468747874887498750875187528753875487558756875787588759876087618762876387648765876687678768876987708771877287738774877587768777877887798780878187828783878487858786878787888789879087918792879387948795879687978798879988008801880288038804880588068807880888098810881188128813881488158816881788188819882088218822882388248825882688278828882988308831883288338834883588368837883888398840884188428843884488458846884788488849885088518852885388548855885688578858885988608861886288638864886588668867886888698870887188728873887488758876887788788879888088818882888388848885888688878888888988908891889288938894889588968897889888998900890189028903890489058906890789088909891089118912891389148915891689178918891989208921892289238924892589268927892889298930893189328933893489358936893789388939894089418942894389448945894689478948894989508951895289538954895589568957895889598960896189628963896489658966896789688969897089718972897389748975897689778978897989808981898289838984898589868987898889898990899189928993899489958996899789988999900090019002900390049005900690079008900990109011901290139014901590169017901890199020902190229023902490259026902790289029903090319032903390349035903690379038903990409041904290439044904590469047904890499050905190529053905490559056905790589059906090619062906390649065906690679068906990709071907290739074907590769077907890799080908190829083908490859086908790889089909090919092909390949095909690979098909991009101910291039104910591069107910891099110911191129113911491159116911791189119912091219122912391249125912691279128912991309131913291339134913591369137913891399140914191429143914491459146914791489149915091519152915391549155915691579158915991609161916291639164916591669167916891699170917191729173917491759176917791789179918091819182918391849185918691879188918991909191919291939194919591969197919891999200920192029203920492059206920792089209921092119212921392149215921692179218921992209221922292239224922592269227922892299230923192329233923492359236923792389239924092419242924392449245924692479248924992509251925292539254925592569257925892599260926192629263926492659266926792689269927092719272927392749275927692779278927992809281928292839284928592869287928892899290929192929293929492959296929792989299930093019302930393049305930693079308930993109311931293139314931593169317931893199320932193229323932493259326932793289329933093319332933393349335933693379338933993409341934293439344934593469347934893499350935193529353935493559356935793589359936093619362936393649365936693679368936993709371937293739374937593769377937893799380938193829383938493859386938793889389939093919392939393949395939693979398939994009401940294039404940594069407940894099410941194129413941494159416941794189419942094219422942394249425942694279428942994309431943294339434943594369437943894399440944194429443944494459446944794489449945094519452945394549455945694579458945994609461946294639464946594669467946894699470947194729473947494759476947794789479948094819482948394849485948694879488948994909491949294939494949594969497949894999500950195029503950495059506950795089509951095119512951395149515951695179518951995209521952295239524952595269527952895299530953195329533953495359536953795389539954095419542954395449545954695479548954995509551955295539554955595569557955895599560956195629563956495659566956795689569957095719572957395749575957695779578957995809581958295839584958595869587958895899590959195929593959495959596959795989599960096019602960396049605960696079608960996109611961296139614961596169617961896199620962196229623962496259626962796289629963096319632963396349635963696379638963996409641964296439644964596469647964896499650965196529653965496559656965796589659966096619662966396649665966696679668966996709671967296739674967596769677967896799680968196829683968496859686968796889689969096919692969396949695969696979698969997009701970297039704970597069707970897099710971197129713971497159716971797189719972097219722972397249725972697279728972997309731973297339734973597369737973897399740974197429743974497459746974797489749975097519752975397549755975697579758975997609761976297639764976597669767976897699770977197729773977497759776977797789779978097819782978397849785978697879788978997909791979297939794979597969797979897999800980198029803980498059806980798089809981098119812981398149815981698179818981998209821982298239824982598269827982898299830983198329833983498359836983798389839984098419842984398449845984698479848984998509851985298539854985598569857985898599860986198629863986498659866986798689869987098719872987398749875987698779878987998809881988298839884988598869887988898899890
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. md.c : Multiple Devices driver for Linux
  4. Copyright (C) 1998, 1999, 2000 Ingo Molnar
  5. completely rewritten, based on the MD driver code from Marc Zyngier
  6. Changes:
  7. - RAID-1/RAID-5 extensions by Miguel de Icaza, Gadi Oxman, Ingo Molnar
  8. - RAID-6 extensions by H. Peter Anvin <hpa@zytor.com>
  9. - boot support for linear and striped mode by Harald Hoyer <HarryH@Royal.Net>
  10. - kerneld support by Boris Tobotras <boris@xtalk.msk.su>
  11. - kmod support by: Cyrus Durgin
  12. - RAID0 bugfixes: Mark Anthony Lisher <markal@iname.com>
  13. - Devfs support by Richard Gooch <rgooch@atnf.csiro.au>
  14. - lots of fixes and improvements to the RAID1/RAID5 and generic
  15. RAID code (such as request based resynchronization):
  16. Neil Brown <neilb@cse.unsw.edu.au>.
  17. - persistent bitmap code
  18. Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.
  19. Errors, Warnings, etc.
  20. Please use:
  21. pr_crit() for error conditions that risk data loss
  22. pr_err() for error conditions that are unexpected, like an IO error
  23. or internal inconsistency
  24. pr_warn() for error conditions that could have been predicated, like
  25. adding a device to an array when it has incompatible metadata
  26. pr_info() for every interesting, very rare events, like an array starting
  27. or stopping, or resync starting or stopping
  28. pr_debug() for everything else.
  29. */
  30. #include <linux/sched/mm.h>
  31. #include <linux/sched/signal.h>
  32. #include <linux/kthread.h>
  33. #include <linux/blkdev.h>
  34. #include <linux/badblocks.h>
  35. #include <linux/sysctl.h>
  36. #include <linux/seq_file.h>
  37. #include <linux/fs.h>
  38. #include <linux/poll.h>
  39. #include <linux/ctype.h>
  40. #include <linux/string.h>
  41. #include <linux/hdreg.h>
  42. #include <linux/proc_fs.h>
  43. #include <linux/random.h>
  44. #include <linux/module.h>
  45. #include <linux/reboot.h>
  46. #include <linux/file.h>
  47. #include <linux/compat.h>
  48. #include <linux/delay.h>
  49. #include <linux/raid/md_p.h>
  50. #include <linux/raid/md_u.h>
  51. #include <linux/raid/detect.h>
  52. #include <linux/slab.h>
  53. #include <linux/percpu-refcount.h>
  54. #include <linux/part_stat.h>
  55. #include <trace/events/block.h>
  56. #include "md.h"
  57. #include "md-bitmap.h"
  58. #include "md-cluster.h"
  59. /* pers_list is a list of registered personalities protected
  60. * by pers_lock.
  61. * pers_lock does extra service to protect accesses to
  62. * mddev->thread when the mutex cannot be held.
  63. */
  64. static LIST_HEAD(pers_list);
  65. static DEFINE_SPINLOCK(pers_lock);
  66. static struct kobj_type md_ktype;
  67. struct md_cluster_operations *md_cluster_ops;
  68. EXPORT_SYMBOL(md_cluster_ops);
  69. static struct module *md_cluster_mod;
  70. static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
  71. static struct workqueue_struct *md_wq;
  72. static struct workqueue_struct *md_misc_wq;
  73. static struct workqueue_struct *md_rdev_misc_wq;
  74. static int remove_and_add_spares(struct mddev *mddev,
  75. struct md_rdev *this);
  76. static void mddev_detach(struct mddev *mddev);
  77. /*
  78. * Default number of read corrections we'll attempt on an rdev
  79. * before ejecting it from the array. We divide the read error
  80. * count by 2 for every hour elapsed between read errors.
  81. */
  82. #define MD_DEFAULT_MAX_CORRECTED_READ_ERRORS 20
  83. /* Default safemode delay: 200 msec */
  84. #define DEFAULT_SAFEMODE_DELAY ((200 * HZ)/1000 +1)
  85. /*
  86. * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
  87. * is 1000 KB/sec, so the extra system load does not show up that much.
  88. * Increase it if you want to have more _guaranteed_ speed. Note that
  89. * the RAID driver will use the maximum available bandwidth if the IO
  90. * subsystem is idle. There is also an 'absolute maximum' reconstruction
  91. * speed limit - in case reconstruction slows down your system despite
  92. * idle IO detection.
  93. *
  94. * you can change it via /proc/sys/dev/raid/speed_limit_min and _max.
  95. * or /sys/block/mdX/md/sync_speed_{min,max}
  96. */
  97. static int sysctl_speed_limit_min = 1000;
  98. static int sysctl_speed_limit_max = 200000;
  99. static inline int speed_min(struct mddev *mddev)
  100. {
  101. return mddev->sync_speed_min ?
  102. mddev->sync_speed_min : sysctl_speed_limit_min;
  103. }
  104. static inline int speed_max(struct mddev *mddev)
  105. {
  106. return mddev->sync_speed_max ?
  107. mddev->sync_speed_max : sysctl_speed_limit_max;
  108. }
  109. static void rdev_uninit_serial(struct md_rdev *rdev)
  110. {
  111. if (!test_and_clear_bit(CollisionCheck, &rdev->flags))
  112. return;
  113. kvfree(rdev->serial);
  114. rdev->serial = NULL;
  115. }
  116. static void rdevs_uninit_serial(struct mddev *mddev)
  117. {
  118. struct md_rdev *rdev;
  119. rdev_for_each(rdev, mddev)
  120. rdev_uninit_serial(rdev);
  121. }
  122. static int rdev_init_serial(struct md_rdev *rdev)
  123. {
  124. /* serial_nums equals with BARRIER_BUCKETS_NR */
  125. int i, serial_nums = 1 << ((PAGE_SHIFT - ilog2(sizeof(atomic_t))));
  126. struct serial_in_rdev *serial = NULL;
  127. if (test_bit(CollisionCheck, &rdev->flags))
  128. return 0;
  129. serial = kvmalloc(sizeof(struct serial_in_rdev) * serial_nums,
  130. GFP_KERNEL);
  131. if (!serial)
  132. return -ENOMEM;
  133. for (i = 0; i < serial_nums; i++) {
  134. struct serial_in_rdev *serial_tmp = &serial[i];
  135. spin_lock_init(&serial_tmp->serial_lock);
  136. serial_tmp->serial_rb = RB_ROOT_CACHED;
  137. init_waitqueue_head(&serial_tmp->serial_io_wait);
  138. }
  139. rdev->serial = serial;
  140. set_bit(CollisionCheck, &rdev->flags);
  141. return 0;
  142. }
  143. static int rdevs_init_serial(struct mddev *mddev)
  144. {
  145. struct md_rdev *rdev;
  146. int ret = 0;
  147. rdev_for_each(rdev, mddev) {
  148. ret = rdev_init_serial(rdev);
  149. if (ret)
  150. break;
  151. }
  152. /* Free all resources if pool is not existed */
  153. if (ret && !mddev->serial_info_pool)
  154. rdevs_uninit_serial(mddev);
  155. return ret;
  156. }
  157. /*
  158. * rdev needs to enable serial stuffs if it meets the conditions:
  159. * 1. it is multi-queue device flaged with writemostly.
  160. * 2. the write-behind mode is enabled.
  161. */
  162. static int rdev_need_serial(struct md_rdev *rdev)
  163. {
  164. return (rdev && rdev->mddev->bitmap_info.max_write_behind > 0 &&
  165. rdev->bdev->bd_disk->queue->nr_hw_queues != 1 &&
  166. test_bit(WriteMostly, &rdev->flags));
  167. }
  168. /*
  169. * Init resource for rdev(s), then create serial_info_pool if:
  170. * 1. rdev is the first device which return true from rdev_enable_serial.
  171. * 2. rdev is NULL, means we want to enable serialization for all rdevs.
  172. */
  173. void mddev_create_serial_pool(struct mddev *mddev, struct md_rdev *rdev,
  174. bool is_suspend)
  175. {
  176. int ret = 0;
  177. if (rdev && !rdev_need_serial(rdev) &&
  178. !test_bit(CollisionCheck, &rdev->flags))
  179. return;
  180. if (!is_suspend)
  181. mddev_suspend(mddev);
  182. if (!rdev)
  183. ret = rdevs_init_serial(mddev);
  184. else
  185. ret = rdev_init_serial(rdev);
  186. if (ret)
  187. goto abort;
  188. if (mddev->serial_info_pool == NULL) {
  189. /*
  190. * already in memalloc noio context by
  191. * mddev_suspend()
  192. */
  193. mddev->serial_info_pool =
  194. mempool_create_kmalloc_pool(NR_SERIAL_INFOS,
  195. sizeof(struct serial_info));
  196. if (!mddev->serial_info_pool) {
  197. rdevs_uninit_serial(mddev);
  198. pr_err("can't alloc memory pool for serialization\n");
  199. }
  200. }
  201. abort:
  202. if (!is_suspend)
  203. mddev_resume(mddev);
  204. }
  205. /*
  206. * Free resource from rdev(s), and destroy serial_info_pool under conditions:
  207. * 1. rdev is the last device flaged with CollisionCheck.
  208. * 2. when bitmap is destroyed while policy is not enabled.
  209. * 3. for disable policy, the pool is destroyed only when no rdev needs it.
  210. */
  211. void mddev_destroy_serial_pool(struct mddev *mddev, struct md_rdev *rdev,
  212. bool is_suspend)
  213. {
  214. if (rdev && !test_bit(CollisionCheck, &rdev->flags))
  215. return;
  216. if (mddev->serial_info_pool) {
  217. struct md_rdev *temp;
  218. int num = 0; /* used to track if other rdevs need the pool */
  219. if (!is_suspend)
  220. mddev_suspend(mddev);
  221. rdev_for_each(temp, mddev) {
  222. if (!rdev) {
  223. if (!mddev->serialize_policy ||
  224. !rdev_need_serial(temp))
  225. rdev_uninit_serial(temp);
  226. else
  227. num++;
  228. } else if (temp != rdev &&
  229. test_bit(CollisionCheck, &temp->flags))
  230. num++;
  231. }
  232. if (rdev)
  233. rdev_uninit_serial(rdev);
  234. if (num)
  235. pr_info("The mempool could be used by other devices\n");
  236. else {
  237. mempool_destroy(mddev->serial_info_pool);
  238. mddev->serial_info_pool = NULL;
  239. }
  240. if (!is_suspend)
  241. mddev_resume(mddev);
  242. }
  243. }
  244. static struct ctl_table_header *raid_table_header;
  245. static struct ctl_table raid_table[] = {
  246. {
  247. .procname = "speed_limit_min",
  248. .data = &sysctl_speed_limit_min,
  249. .maxlen = sizeof(int),
  250. .mode = S_IRUGO|S_IWUSR,
  251. .proc_handler = proc_dointvec,
  252. },
  253. {
  254. .procname = "speed_limit_max",
  255. .data = &sysctl_speed_limit_max,
  256. .maxlen = sizeof(int),
  257. .mode = S_IRUGO|S_IWUSR,
  258. .proc_handler = proc_dointvec,
  259. },
  260. { }
  261. };
  262. static struct ctl_table raid_dir_table[] = {
  263. {
  264. .procname = "raid",
  265. .maxlen = 0,
  266. .mode = S_IRUGO|S_IXUGO,
  267. .child = raid_table,
  268. },
  269. { }
  270. };
  271. static struct ctl_table raid_root_table[] = {
  272. {
  273. .procname = "dev",
  274. .maxlen = 0,
  275. .mode = 0555,
  276. .child = raid_dir_table,
  277. },
  278. { }
  279. };
  280. static int start_readonly;
  281. /*
  282. * The original mechanism for creating an md device is to create
  283. * a device node in /dev and to open it. This causes races with device-close.
  284. * The preferred method is to write to the "new_array" module parameter.
  285. * This can avoid races.
  286. * Setting create_on_open to false disables the original mechanism
  287. * so all the races disappear.
  288. */
  289. static bool create_on_open = true;
  290. struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
  291. struct mddev *mddev)
  292. {
  293. if (!mddev || !bioset_initialized(&mddev->bio_set))
  294. return bio_alloc(gfp_mask, nr_iovecs);
  295. return bio_alloc_bioset(gfp_mask, nr_iovecs, &mddev->bio_set);
  296. }
  297. EXPORT_SYMBOL_GPL(bio_alloc_mddev);
  298. static struct bio *md_bio_alloc_sync(struct mddev *mddev)
  299. {
  300. if (!mddev || !bioset_initialized(&mddev->sync_set))
  301. return bio_alloc(GFP_NOIO, 1);
  302. return bio_alloc_bioset(GFP_NOIO, 1, &mddev->sync_set);
  303. }
  304. /*
  305. * We have a system wide 'event count' that is incremented
  306. * on any 'interesting' event, and readers of /proc/mdstat
  307. * can use 'poll' or 'select' to find out when the event
  308. * count increases.
  309. *
  310. * Events are:
  311. * start array, stop array, error, add device, remove device,
  312. * start build, activate spare
  313. */
  314. static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
  315. static atomic_t md_event_count;
  316. void md_new_event(struct mddev *mddev)
  317. {
  318. atomic_inc(&md_event_count);
  319. wake_up(&md_event_waiters);
  320. }
  321. EXPORT_SYMBOL_GPL(md_new_event);
  322. /*
  323. * Enables to iterate over all existing md arrays
  324. * all_mddevs_lock protects this list.
  325. */
  326. static LIST_HEAD(all_mddevs);
  327. static DEFINE_SPINLOCK(all_mddevs_lock);
  328. /*
  329. * iterates through all used mddevs in the system.
  330. * We take care to grab the all_mddevs_lock whenever navigating
  331. * the list, and to always hold a refcount when unlocked.
  332. * Any code which breaks out of this loop while own
  333. * a reference to the current mddev and must mddev_put it.
  334. */
  335. #define for_each_mddev(_mddev,_tmp) \
  336. \
  337. for (({ spin_lock(&all_mddevs_lock); \
  338. _tmp = all_mddevs.next; \
  339. _mddev = NULL;}); \
  340. ({ if (_tmp != &all_mddevs) \
  341. mddev_get(list_entry(_tmp, struct mddev, all_mddevs));\
  342. spin_unlock(&all_mddevs_lock); \
  343. if (_mddev) mddev_put(_mddev); \
  344. _mddev = list_entry(_tmp, struct mddev, all_mddevs); \
  345. _tmp != &all_mddevs;}); \
  346. ({ spin_lock(&all_mddevs_lock); \
  347. _tmp = _tmp->next;}) \
  348. )
  349. /* Rather than calling directly into the personality make_request function,
  350. * IO requests come here first so that we can check if the device is
  351. * being suspended pending a reconfiguration.
  352. * We hold a refcount over the call to ->make_request. By the time that
  353. * call has finished, the bio has been linked into some internal structure
  354. * and so is visible to ->quiesce(), so we don't need the refcount any more.
  355. */
  356. static bool is_suspended(struct mddev *mddev, struct bio *bio)
  357. {
  358. if (mddev->suspended)
  359. return true;
  360. if (bio_data_dir(bio) != WRITE)
  361. return false;
  362. if (mddev->suspend_lo >= mddev->suspend_hi)
  363. return false;
  364. if (bio->bi_iter.bi_sector >= mddev->suspend_hi)
  365. return false;
  366. if (bio_end_sector(bio) < mddev->suspend_lo)
  367. return false;
  368. return true;
  369. }
  370. void md_handle_request(struct mddev *mddev, struct bio *bio)
  371. {
  372. check_suspended:
  373. rcu_read_lock();
  374. if (is_suspended(mddev, bio)) {
  375. DEFINE_WAIT(__wait);
  376. for (;;) {
  377. prepare_to_wait(&mddev->sb_wait, &__wait,
  378. TASK_UNINTERRUPTIBLE);
  379. if (!is_suspended(mddev, bio))
  380. break;
  381. rcu_read_unlock();
  382. schedule();
  383. rcu_read_lock();
  384. }
  385. finish_wait(&mddev->sb_wait, &__wait);
  386. }
  387. atomic_inc(&mddev->active_io);
  388. rcu_read_unlock();
  389. if (!mddev->pers->make_request(mddev, bio)) {
  390. atomic_dec(&mddev->active_io);
  391. wake_up(&mddev->sb_wait);
  392. goto check_suspended;
  393. }
  394. if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended)
  395. wake_up(&mddev->sb_wait);
  396. }
  397. EXPORT_SYMBOL(md_handle_request);
  398. static blk_qc_t md_submit_bio(struct bio *bio)
  399. {
  400. const int rw = bio_data_dir(bio);
  401. const int sgrp = op_stat_group(bio_op(bio));
  402. struct mddev *mddev = bio->bi_disk->private_data;
  403. unsigned int sectors;
  404. if (mddev == NULL || mddev->pers == NULL) {
  405. bio_io_error(bio);
  406. return BLK_QC_T_NONE;
  407. }
  408. if (unlikely(test_bit(MD_BROKEN, &mddev->flags)) && (rw == WRITE)) {
  409. bio_io_error(bio);
  410. return BLK_QC_T_NONE;
  411. }
  412. blk_queue_split(&bio);
  413. if (mddev->ro == 1 && unlikely(rw == WRITE)) {
  414. if (bio_sectors(bio) != 0)
  415. bio->bi_status = BLK_STS_IOERR;
  416. bio_endio(bio);
  417. return BLK_QC_T_NONE;
  418. }
  419. /*
  420. * save the sectors now since our bio can
  421. * go away inside make_request
  422. */
  423. sectors = bio_sectors(bio);
  424. /* bio could be mergeable after passing to underlayer */
  425. bio->bi_opf &= ~REQ_NOMERGE;
  426. md_handle_request(mddev, bio);
  427. part_stat_lock();
  428. part_stat_inc(&mddev->gendisk->part0, ios[sgrp]);
  429. part_stat_add(&mddev->gendisk->part0, sectors[sgrp], sectors);
  430. part_stat_unlock();
  431. return BLK_QC_T_NONE;
  432. }
  433. /* mddev_suspend makes sure no new requests are submitted
  434. * to the device, and that any requests that have been submitted
  435. * are completely handled.
  436. * Once mddev_detach() is called and completes, the module will be
  437. * completely unused.
  438. */
  439. void mddev_suspend(struct mddev *mddev)
  440. {
  441. WARN_ON_ONCE(mddev->thread && current == mddev->thread->tsk);
  442. lockdep_assert_held(&mddev->reconfig_mutex);
  443. if (mddev->suspended++)
  444. return;
  445. synchronize_rcu();
  446. wake_up(&mddev->sb_wait);
  447. set_bit(MD_ALLOW_SB_UPDATE, &mddev->flags);
  448. smp_mb__after_atomic();
  449. wait_event(mddev->sb_wait, atomic_read(&mddev->active_io) == 0);
  450. mddev->pers->quiesce(mddev, 1);
  451. clear_bit_unlock(MD_ALLOW_SB_UPDATE, &mddev->flags);
  452. wait_event(mddev->sb_wait, !test_bit(MD_UPDATING_SB, &mddev->flags));
  453. del_timer_sync(&mddev->safemode_timer);
  454. /* restrict memory reclaim I/O during raid array is suspend */
  455. mddev->noio_flag = memalloc_noio_save();
  456. }
  457. EXPORT_SYMBOL_GPL(mddev_suspend);
  458. void mddev_resume(struct mddev *mddev)
  459. {
  460. /* entred the memalloc scope from mddev_suspend() */
  461. memalloc_noio_restore(mddev->noio_flag);
  462. lockdep_assert_held(&mddev->reconfig_mutex);
  463. if (--mddev->suspended)
  464. return;
  465. wake_up(&mddev->sb_wait);
  466. mddev->pers->quiesce(mddev, 0);
  467. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  468. md_wakeup_thread(mddev->thread);
  469. md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
  470. }
  471. EXPORT_SYMBOL_GPL(mddev_resume);
  472. /*
  473. * Generic flush handling for md
  474. */
  475. static void md_end_flush(struct bio *bio)
  476. {
  477. struct md_rdev *rdev = bio->bi_private;
  478. struct mddev *mddev = rdev->mddev;
  479. rdev_dec_pending(rdev, mddev);
  480. if (atomic_dec_and_test(&mddev->flush_pending)) {
  481. /* The pre-request flush has finished */
  482. queue_work(md_wq, &mddev->flush_work);
  483. }
  484. bio_put(bio);
  485. }
  486. static void md_submit_flush_data(struct work_struct *ws);
  487. static void submit_flushes(struct work_struct *ws)
  488. {
  489. struct mddev *mddev = container_of(ws, struct mddev, flush_work);
  490. struct md_rdev *rdev;
  491. mddev->start_flush = ktime_get_boottime();
  492. INIT_WORK(&mddev->flush_work, md_submit_flush_data);
  493. atomic_set(&mddev->flush_pending, 1);
  494. rcu_read_lock();
  495. rdev_for_each_rcu(rdev, mddev)
  496. if (rdev->raid_disk >= 0 &&
  497. !test_bit(Faulty, &rdev->flags)) {
  498. /* Take two references, one is dropped
  499. * when request finishes, one after
  500. * we reclaim rcu_read_lock
  501. */
  502. struct bio *bi;
  503. atomic_inc(&rdev->nr_pending);
  504. atomic_inc(&rdev->nr_pending);
  505. rcu_read_unlock();
  506. bi = bio_alloc_mddev(GFP_NOIO, 0, mddev);
  507. bi->bi_end_io = md_end_flush;
  508. bi->bi_private = rdev;
  509. bio_set_dev(bi, rdev->bdev);
  510. bi->bi_opf = REQ_OP_WRITE | REQ_PREFLUSH;
  511. atomic_inc(&mddev->flush_pending);
  512. submit_bio(bi);
  513. rcu_read_lock();
  514. rdev_dec_pending(rdev, mddev);
  515. }
  516. rcu_read_unlock();
  517. if (atomic_dec_and_test(&mddev->flush_pending))
  518. queue_work(md_wq, &mddev->flush_work);
  519. }
  520. static void md_submit_flush_data(struct work_struct *ws)
  521. {
  522. struct mddev *mddev = container_of(ws, struct mddev, flush_work);
  523. struct bio *bio = mddev->flush_bio;
  524. /*
  525. * must reset flush_bio before calling into md_handle_request to avoid a
  526. * deadlock, because other bios passed md_handle_request suspend check
  527. * could wait for this and below md_handle_request could wait for those
  528. * bios because of suspend check
  529. */
  530. spin_lock_irq(&mddev->lock);
  531. mddev->last_flush = mddev->start_flush;
  532. mddev->flush_bio = NULL;
  533. spin_unlock_irq(&mddev->lock);
  534. wake_up(&mddev->sb_wait);
  535. if (bio->bi_iter.bi_size == 0) {
  536. /* an empty barrier - all done */
  537. bio_endio(bio);
  538. } else {
  539. bio->bi_opf &= ~REQ_PREFLUSH;
  540. md_handle_request(mddev, bio);
  541. }
  542. }
  543. /*
  544. * Manages consolidation of flushes and submitting any flushes needed for
  545. * a bio with REQ_PREFLUSH. Returns true if the bio is finished or is
  546. * being finished in another context. Returns false if the flushing is
  547. * complete but still needs the I/O portion of the bio to be processed.
  548. */
  549. bool md_flush_request(struct mddev *mddev, struct bio *bio)
  550. {
  551. ktime_t start = ktime_get_boottime();
  552. spin_lock_irq(&mddev->lock);
  553. wait_event_lock_irq(mddev->sb_wait,
  554. !mddev->flush_bio ||
  555. ktime_after(mddev->last_flush, start),
  556. mddev->lock);
  557. if (!ktime_after(mddev->last_flush, start)) {
  558. WARN_ON(mddev->flush_bio);
  559. mddev->flush_bio = bio;
  560. bio = NULL;
  561. }
  562. spin_unlock_irq(&mddev->lock);
  563. if (!bio) {
  564. INIT_WORK(&mddev->flush_work, submit_flushes);
  565. queue_work(md_wq, &mddev->flush_work);
  566. } else {
  567. /* flush was performed for some other bio while we waited. */
  568. if (bio->bi_iter.bi_size == 0)
  569. /* an empty barrier - all done */
  570. bio_endio(bio);
  571. else {
  572. bio->bi_opf &= ~REQ_PREFLUSH;
  573. return false;
  574. }
  575. }
  576. return true;
  577. }
  578. EXPORT_SYMBOL(md_flush_request);
  579. static inline struct mddev *mddev_get(struct mddev *mddev)
  580. {
  581. atomic_inc(&mddev->active);
  582. return mddev;
  583. }
  584. static void mddev_delayed_delete(struct work_struct *ws);
  585. static void mddev_put(struct mddev *mddev)
  586. {
  587. if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
  588. return;
  589. if (!mddev->raid_disks && list_empty(&mddev->disks) &&
  590. mddev->ctime == 0 && !mddev->hold_active) {
  591. /* Array is not configured at all, and not held active,
  592. * so destroy it */
  593. list_del_init(&mddev->all_mddevs);
  594. /*
  595. * Call queue_work inside the spinlock so that
  596. * flush_workqueue() after mddev_find will succeed in waiting
  597. * for the work to be done.
  598. */
  599. INIT_WORK(&mddev->del_work, mddev_delayed_delete);
  600. queue_work(md_misc_wq, &mddev->del_work);
  601. }
  602. spin_unlock(&all_mddevs_lock);
  603. }
  604. static void md_safemode_timeout(struct timer_list *t);
  605. void mddev_init(struct mddev *mddev)
  606. {
  607. kobject_init(&mddev->kobj, &md_ktype);
  608. mutex_init(&mddev->open_mutex);
  609. mutex_init(&mddev->reconfig_mutex);
  610. mutex_init(&mddev->bitmap_info.mutex);
  611. INIT_LIST_HEAD(&mddev->disks);
  612. INIT_LIST_HEAD(&mddev->all_mddevs);
  613. timer_setup(&mddev->safemode_timer, md_safemode_timeout, 0);
  614. atomic_set(&mddev->active, 1);
  615. atomic_set(&mddev->openers, 0);
  616. atomic_set(&mddev->active_io, 0);
  617. spin_lock_init(&mddev->lock);
  618. atomic_set(&mddev->flush_pending, 0);
  619. init_waitqueue_head(&mddev->sb_wait);
  620. init_waitqueue_head(&mddev->recovery_wait);
  621. mddev->reshape_position = MaxSector;
  622. mddev->reshape_backwards = 0;
  623. mddev->last_sync_action = "none";
  624. mddev->resync_min = 0;
  625. mddev->resync_max = MaxSector;
  626. mddev->level = LEVEL_NONE;
  627. }
  628. EXPORT_SYMBOL_GPL(mddev_init);
  629. static struct mddev *mddev_find_locked(dev_t unit)
  630. {
  631. struct mddev *mddev;
  632. list_for_each_entry(mddev, &all_mddevs, all_mddevs)
  633. if (mddev->unit == unit)
  634. return mddev;
  635. return NULL;
  636. }
  637. static struct mddev *mddev_find(dev_t unit)
  638. {
  639. struct mddev *mddev;
  640. if (MAJOR(unit) != MD_MAJOR)
  641. unit &= ~((1 << MdpMinorShift) - 1);
  642. spin_lock(&all_mddevs_lock);
  643. mddev = mddev_find_locked(unit);
  644. if (mddev)
  645. mddev_get(mddev);
  646. spin_unlock(&all_mddevs_lock);
  647. return mddev;
  648. }
  649. static struct mddev *mddev_find_or_alloc(dev_t unit)
  650. {
  651. struct mddev *mddev, *new = NULL;
  652. if (unit && MAJOR(unit) != MD_MAJOR)
  653. unit &= ~((1<<MdpMinorShift)-1);
  654. retry:
  655. spin_lock(&all_mddevs_lock);
  656. if (unit) {
  657. mddev = mddev_find_locked(unit);
  658. if (mddev) {
  659. mddev_get(mddev);
  660. spin_unlock(&all_mddevs_lock);
  661. kfree(new);
  662. return mddev;
  663. }
  664. if (new) {
  665. list_add(&new->all_mddevs, &all_mddevs);
  666. spin_unlock(&all_mddevs_lock);
  667. new->hold_active = UNTIL_IOCTL;
  668. return new;
  669. }
  670. } else if (new) {
  671. /* find an unused unit number */
  672. static int next_minor = 512;
  673. int start = next_minor;
  674. int is_free = 0;
  675. int dev = 0;
  676. while (!is_free) {
  677. dev = MKDEV(MD_MAJOR, next_minor);
  678. next_minor++;
  679. if (next_minor > MINORMASK)
  680. next_minor = 0;
  681. if (next_minor == start) {
  682. /* Oh dear, all in use. */
  683. spin_unlock(&all_mddevs_lock);
  684. kfree(new);
  685. return NULL;
  686. }
  687. is_free = !mddev_find_locked(dev);
  688. }
  689. new->unit = dev;
  690. new->md_minor = MINOR(dev);
  691. new->hold_active = UNTIL_STOP;
  692. list_add(&new->all_mddevs, &all_mddevs);
  693. spin_unlock(&all_mddevs_lock);
  694. return new;
  695. }
  696. spin_unlock(&all_mddevs_lock);
  697. new = kzalloc(sizeof(*new), GFP_KERNEL);
  698. if (!new)
  699. return NULL;
  700. new->unit = unit;
  701. if (MAJOR(unit) == MD_MAJOR)
  702. new->md_minor = MINOR(unit);
  703. else
  704. new->md_minor = MINOR(unit) >> MdpMinorShift;
  705. mddev_init(new);
  706. goto retry;
  707. }
  708. static struct attribute_group md_redundancy_group;
  709. void mddev_unlock(struct mddev *mddev)
  710. {
  711. if (mddev->to_remove) {
  712. /* These cannot be removed under reconfig_mutex as
  713. * an access to the files will try to take reconfig_mutex
  714. * while holding the file unremovable, which leads to
  715. * a deadlock.
  716. * So hold set sysfs_active while the remove in happeing,
  717. * and anything else which might set ->to_remove or my
  718. * otherwise change the sysfs namespace will fail with
  719. * -EBUSY if sysfs_active is still set.
  720. * We set sysfs_active under reconfig_mutex and elsewhere
  721. * test it under the same mutex to ensure its correct value
  722. * is seen.
  723. */
  724. struct attribute_group *to_remove = mddev->to_remove;
  725. mddev->to_remove = NULL;
  726. mddev->sysfs_active = 1;
  727. mutex_unlock(&mddev->reconfig_mutex);
  728. if (mddev->kobj.sd) {
  729. if (to_remove != &md_redundancy_group)
  730. sysfs_remove_group(&mddev->kobj, to_remove);
  731. if (mddev->pers == NULL ||
  732. mddev->pers->sync_request == NULL) {
  733. sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
  734. if (mddev->sysfs_action)
  735. sysfs_put(mddev->sysfs_action);
  736. if (mddev->sysfs_completed)
  737. sysfs_put(mddev->sysfs_completed);
  738. if (mddev->sysfs_degraded)
  739. sysfs_put(mddev->sysfs_degraded);
  740. mddev->sysfs_action = NULL;
  741. mddev->sysfs_completed = NULL;
  742. mddev->sysfs_degraded = NULL;
  743. }
  744. }
  745. mddev->sysfs_active = 0;
  746. } else
  747. mutex_unlock(&mddev->reconfig_mutex);
  748. /* As we've dropped the mutex we need a spinlock to
  749. * make sure the thread doesn't disappear
  750. */
  751. spin_lock(&pers_lock);
  752. md_wakeup_thread(mddev->thread);
  753. wake_up(&mddev->sb_wait);
  754. spin_unlock(&pers_lock);
  755. }
  756. EXPORT_SYMBOL_GPL(mddev_unlock);
  757. struct md_rdev *md_find_rdev_nr_rcu(struct mddev *mddev, int nr)
  758. {
  759. struct md_rdev *rdev;
  760. rdev_for_each_rcu(rdev, mddev)
  761. if (rdev->desc_nr == nr)
  762. return rdev;
  763. return NULL;
  764. }
  765. EXPORT_SYMBOL_GPL(md_find_rdev_nr_rcu);
  766. static struct md_rdev *find_rdev(struct mddev *mddev, dev_t dev)
  767. {
  768. struct md_rdev *rdev;
  769. rdev_for_each(rdev, mddev)
  770. if (rdev->bdev->bd_dev == dev)
  771. return rdev;
  772. return NULL;
  773. }
  774. struct md_rdev *md_find_rdev_rcu(struct mddev *mddev, dev_t dev)
  775. {
  776. struct md_rdev *rdev;
  777. rdev_for_each_rcu(rdev, mddev)
  778. if (rdev->bdev->bd_dev == dev)
  779. return rdev;
  780. return NULL;
  781. }
  782. EXPORT_SYMBOL_GPL(md_find_rdev_rcu);
  783. static struct md_personality *find_pers(int level, char *clevel)
  784. {
  785. struct md_personality *pers;
  786. list_for_each_entry(pers, &pers_list, list) {
  787. if (level != LEVEL_NONE && pers->level == level)
  788. return pers;
  789. if (strcmp(pers->name, clevel)==0)
  790. return pers;
  791. }
  792. return NULL;
  793. }
  794. /* return the offset of the super block in 512byte sectors */
  795. static inline sector_t calc_dev_sboffset(struct md_rdev *rdev)
  796. {
  797. sector_t num_sectors = i_size_read(rdev->bdev->bd_inode) / 512;
  798. return MD_NEW_SIZE_SECTORS(num_sectors);
  799. }
  800. static int alloc_disk_sb(struct md_rdev *rdev)
  801. {
  802. rdev->sb_page = alloc_page(GFP_KERNEL);
  803. if (!rdev->sb_page)
  804. return -ENOMEM;
  805. return 0;
  806. }
  807. void md_rdev_clear(struct md_rdev *rdev)
  808. {
  809. if (rdev->sb_page) {
  810. put_page(rdev->sb_page);
  811. rdev->sb_loaded = 0;
  812. rdev->sb_page = NULL;
  813. rdev->sb_start = 0;
  814. rdev->sectors = 0;
  815. }
  816. if (rdev->bb_page) {
  817. put_page(rdev->bb_page);
  818. rdev->bb_page = NULL;
  819. }
  820. badblocks_exit(&rdev->badblocks);
  821. }
  822. EXPORT_SYMBOL_GPL(md_rdev_clear);
  823. static void super_written(struct bio *bio)
  824. {
  825. struct md_rdev *rdev = bio->bi_private;
  826. struct mddev *mddev = rdev->mddev;
  827. if (bio->bi_status) {
  828. pr_err("md: %s gets error=%d\n", __func__,
  829. blk_status_to_errno(bio->bi_status));
  830. md_error(mddev, rdev);
  831. if (!test_bit(Faulty, &rdev->flags)
  832. && (bio->bi_opf & MD_FAILFAST)) {
  833. set_bit(MD_SB_NEED_REWRITE, &mddev->sb_flags);
  834. set_bit(LastDev, &rdev->flags);
  835. }
  836. } else
  837. clear_bit(LastDev, &rdev->flags);
  838. if (atomic_dec_and_test(&mddev->pending_writes))
  839. wake_up(&mddev->sb_wait);
  840. rdev_dec_pending(rdev, mddev);
  841. bio_put(bio);
  842. }
  843. void md_super_write(struct mddev *mddev, struct md_rdev *rdev,
  844. sector_t sector, int size, struct page *page)
  845. {
  846. /* write first size bytes of page to sector of rdev
  847. * Increment mddev->pending_writes before returning
  848. * and decrement it on completion, waking up sb_wait
  849. * if zero is reached.
  850. * If an error occurred, call md_error
  851. */
  852. struct bio *bio;
  853. int ff = 0;
  854. if (!page)
  855. return;
  856. if (test_bit(Faulty, &rdev->flags))
  857. return;
  858. bio = md_bio_alloc_sync(mddev);
  859. atomic_inc(&rdev->nr_pending);
  860. bio_set_dev(bio, rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev);
  861. bio->bi_iter.bi_sector = sector;
  862. bio_add_page(bio, page, size, 0);
  863. bio->bi_private = rdev;
  864. bio->bi_end_io = super_written;
  865. if (test_bit(MD_FAILFAST_SUPPORTED, &mddev->flags) &&
  866. test_bit(FailFast, &rdev->flags) &&
  867. !test_bit(LastDev, &rdev->flags))
  868. ff = MD_FAILFAST;
  869. bio->bi_opf = REQ_OP_WRITE | REQ_SYNC | REQ_PREFLUSH | REQ_FUA | ff;
  870. atomic_inc(&mddev->pending_writes);
  871. submit_bio(bio);
  872. }
  873. int md_super_wait(struct mddev *mddev)
  874. {
  875. /* wait for all superblock writes that were scheduled to complete */
  876. wait_event(mddev->sb_wait, atomic_read(&mddev->pending_writes)==0);
  877. if (test_and_clear_bit(MD_SB_NEED_REWRITE, &mddev->sb_flags))
  878. return -EAGAIN;
  879. return 0;
  880. }
  881. int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
  882. struct page *page, int op, int op_flags, bool metadata_op)
  883. {
  884. struct bio *bio = md_bio_alloc_sync(rdev->mddev);
  885. int ret;
  886. if (metadata_op && rdev->meta_bdev)
  887. bio_set_dev(bio, rdev->meta_bdev);
  888. else
  889. bio_set_dev(bio, rdev->bdev);
  890. bio_set_op_attrs(bio, op, op_flags);
  891. if (metadata_op)
  892. bio->bi_iter.bi_sector = sector + rdev->sb_start;
  893. else if (rdev->mddev->reshape_position != MaxSector &&
  894. (rdev->mddev->reshape_backwards ==
  895. (sector >= rdev->mddev->reshape_position)))
  896. bio->bi_iter.bi_sector = sector + rdev->new_data_offset;
  897. else
  898. bio->bi_iter.bi_sector = sector + rdev->data_offset;
  899. bio_add_page(bio, page, size, 0);
  900. submit_bio_wait(bio);
  901. ret = !bio->bi_status;
  902. bio_put(bio);
  903. return ret;
  904. }
  905. EXPORT_SYMBOL_GPL(sync_page_io);
  906. static int read_disk_sb(struct md_rdev *rdev, int size)
  907. {
  908. char b[BDEVNAME_SIZE];
  909. if (rdev->sb_loaded)
  910. return 0;
  911. if (!sync_page_io(rdev, 0, size, rdev->sb_page, REQ_OP_READ, 0, true))
  912. goto fail;
  913. rdev->sb_loaded = 1;
  914. return 0;
  915. fail:
  916. pr_err("md: disabled device %s, could not read superblock.\n",
  917. bdevname(rdev->bdev,b));
  918. return -EINVAL;
  919. }
  920. static int md_uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
  921. {
  922. return sb1->set_uuid0 == sb2->set_uuid0 &&
  923. sb1->set_uuid1 == sb2->set_uuid1 &&
  924. sb1->set_uuid2 == sb2->set_uuid2 &&
  925. sb1->set_uuid3 == sb2->set_uuid3;
  926. }
  927. static int md_sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
  928. {
  929. int ret;
  930. mdp_super_t *tmp1, *tmp2;
  931. tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
  932. tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
  933. if (!tmp1 || !tmp2) {
  934. ret = 0;
  935. goto abort;
  936. }
  937. *tmp1 = *sb1;
  938. *tmp2 = *sb2;
  939. /*
  940. * nr_disks is not constant
  941. */
  942. tmp1->nr_disks = 0;
  943. tmp2->nr_disks = 0;
  944. ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0);
  945. abort:
  946. kfree(tmp1);
  947. kfree(tmp2);
  948. return ret;
  949. }
  950. static u32 md_csum_fold(u32 csum)
  951. {
  952. csum = (csum & 0xffff) + (csum >> 16);
  953. return (csum & 0xffff) + (csum >> 16);
  954. }
  955. static unsigned int calc_sb_csum(mdp_super_t *sb)
  956. {
  957. u64 newcsum = 0;
  958. u32 *sb32 = (u32*)sb;
  959. int i;
  960. unsigned int disk_csum, csum;
  961. disk_csum = sb->sb_csum;
  962. sb->sb_csum = 0;
  963. for (i = 0; i < MD_SB_BYTES/4 ; i++)
  964. newcsum += sb32[i];
  965. csum = (newcsum & 0xffffffff) + (newcsum>>32);
  966. #ifdef CONFIG_ALPHA
  967. /* This used to use csum_partial, which was wrong for several
  968. * reasons including that different results are returned on
  969. * different architectures. It isn't critical that we get exactly
  970. * the same return value as before (we always csum_fold before
  971. * testing, and that removes any differences). However as we
  972. * know that csum_partial always returned a 16bit value on
  973. * alphas, do a fold to maximise conformity to previous behaviour.
  974. */
  975. sb->sb_csum = md_csum_fold(disk_csum);
  976. #else
  977. sb->sb_csum = disk_csum;
  978. #endif
  979. return csum;
  980. }
  981. /*
  982. * Handle superblock details.
  983. * We want to be able to handle multiple superblock formats
  984. * so we have a common interface to them all, and an array of
  985. * different handlers.
  986. * We rely on user-space to write the initial superblock, and support
  987. * reading and updating of superblocks.
  988. * Interface methods are:
  989. * int load_super(struct md_rdev *dev, struct md_rdev *refdev, int minor_version)
  990. * loads and validates a superblock on dev.
  991. * if refdev != NULL, compare superblocks on both devices
  992. * Return:
  993. * 0 - dev has a superblock that is compatible with refdev
  994. * 1 - dev has a superblock that is compatible and newer than refdev
  995. * so dev should be used as the refdev in future
  996. * -EINVAL superblock incompatible or invalid
  997. * -othererror e.g. -EIO
  998. *
  999. * int validate_super(struct mddev *mddev, struct md_rdev *dev)
  1000. * Verify that dev is acceptable into mddev.
  1001. * The first time, mddev->raid_disks will be 0, and data from
  1002. * dev should be merged in. Subsequent calls check that dev
  1003. * is new enough. Return 0 or -EINVAL
  1004. *
  1005. * void sync_super(struct mddev *mddev, struct md_rdev *dev)
  1006. * Update the superblock for rdev with data in mddev
  1007. * This does not write to disc.
  1008. *
  1009. */
  1010. struct super_type {
  1011. char *name;
  1012. struct module *owner;
  1013. int (*load_super)(struct md_rdev *rdev,
  1014. struct md_rdev *refdev,
  1015. int minor_version);
  1016. int (*validate_super)(struct mddev *mddev,
  1017. struct md_rdev *rdev);
  1018. void (*sync_super)(struct mddev *mddev,
  1019. struct md_rdev *rdev);
  1020. unsigned long long (*rdev_size_change)(struct md_rdev *rdev,
  1021. sector_t num_sectors);
  1022. int (*allow_new_offset)(struct md_rdev *rdev,
  1023. unsigned long long new_offset);
  1024. };
  1025. /*
  1026. * Check that the given mddev has no bitmap.
  1027. *
  1028. * This function is called from the run method of all personalities that do not
  1029. * support bitmaps. It prints an error message and returns non-zero if mddev
  1030. * has a bitmap. Otherwise, it returns 0.
  1031. *
  1032. */
  1033. int md_check_no_bitmap(struct mddev *mddev)
  1034. {
  1035. if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)
  1036. return 0;
  1037. pr_warn("%s: bitmaps are not supported for %s\n",
  1038. mdname(mddev), mddev->pers->name);
  1039. return 1;
  1040. }
  1041. EXPORT_SYMBOL(md_check_no_bitmap);
  1042. /*
  1043. * load_super for 0.90.0
  1044. */
  1045. static int super_90_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
  1046. {
  1047. char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
  1048. mdp_super_t *sb;
  1049. int ret;
  1050. bool spare_disk = true;
  1051. /*
  1052. * Calculate the position of the superblock (512byte sectors),
  1053. * it's at the end of the disk.
  1054. *
  1055. * It also happens to be a multiple of 4Kb.
  1056. */
  1057. rdev->sb_start = calc_dev_sboffset(rdev);
  1058. ret = read_disk_sb(rdev, MD_SB_BYTES);
  1059. if (ret)
  1060. return ret;
  1061. ret = -EINVAL;
  1062. bdevname(rdev->bdev, b);
  1063. sb = page_address(rdev->sb_page);
  1064. if (sb->md_magic != MD_SB_MAGIC) {
  1065. pr_warn("md: invalid raid superblock magic on %s\n", b);
  1066. goto abort;
  1067. }
  1068. if (sb->major_version != 0 ||
  1069. sb->minor_version < 90 ||
  1070. sb->minor_version > 91) {
  1071. pr_warn("Bad version number %d.%d on %s\n",
  1072. sb->major_version, sb->minor_version, b);
  1073. goto abort;
  1074. }
  1075. if (sb->raid_disks <= 0)
  1076. goto abort;
  1077. if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) {
  1078. pr_warn("md: invalid superblock checksum on %s\n", b);
  1079. goto abort;
  1080. }
  1081. rdev->preferred_minor = sb->md_minor;
  1082. rdev->data_offset = 0;
  1083. rdev->new_data_offset = 0;
  1084. rdev->sb_size = MD_SB_BYTES;
  1085. rdev->badblocks.shift = -1;
  1086. if (sb->level == LEVEL_MULTIPATH)
  1087. rdev->desc_nr = -1;
  1088. else
  1089. rdev->desc_nr = sb->this_disk.number;
  1090. /* not spare disk, or LEVEL_MULTIPATH */
  1091. if (sb->level == LEVEL_MULTIPATH ||
  1092. (rdev->desc_nr >= 0 &&
  1093. rdev->desc_nr < MD_SB_DISKS &&
  1094. sb->disks[rdev->desc_nr].state &
  1095. ((1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE))))
  1096. spare_disk = false;
  1097. if (!refdev) {
  1098. if (!spare_disk)
  1099. ret = 1;
  1100. else
  1101. ret = 0;
  1102. } else {
  1103. __u64 ev1, ev2;
  1104. mdp_super_t *refsb = page_address(refdev->sb_page);
  1105. if (!md_uuid_equal(refsb, sb)) {
  1106. pr_warn("md: %s has different UUID to %s\n",
  1107. b, bdevname(refdev->bdev,b2));
  1108. goto abort;
  1109. }
  1110. if (!md_sb_equal(refsb, sb)) {
  1111. pr_warn("md: %s has same UUID but different superblock to %s\n",
  1112. b, bdevname(refdev->bdev, b2));
  1113. goto abort;
  1114. }
  1115. ev1 = md_event(sb);
  1116. ev2 = md_event(refsb);
  1117. if (!spare_disk && ev1 > ev2)
  1118. ret = 1;
  1119. else
  1120. ret = 0;
  1121. }
  1122. rdev->sectors = rdev->sb_start;
  1123. /* Limit to 4TB as metadata cannot record more than that.
  1124. * (not needed for Linear and RAID0 as metadata doesn't
  1125. * record this size)
  1126. */
  1127. if ((u64)rdev->sectors >= (2ULL << 32) && sb->level >= 1)
  1128. rdev->sectors = (sector_t)(2ULL << 32) - 2;
  1129. if (rdev->sectors < ((sector_t)sb->size) * 2 && sb->level >= 1)
  1130. /* "this cannot possibly happen" ... */
  1131. ret = -EINVAL;
  1132. abort:
  1133. return ret;
  1134. }
  1135. /*
  1136. * validate_super for 0.90.0
  1137. */
  1138. static int super_90_validate(struct mddev *mddev, struct md_rdev *rdev)
  1139. {
  1140. mdp_disk_t *desc;
  1141. mdp_super_t *sb = page_address(rdev->sb_page);
  1142. __u64 ev1 = md_event(sb);
  1143. rdev->raid_disk = -1;
  1144. clear_bit(Faulty, &rdev->flags);
  1145. clear_bit(In_sync, &rdev->flags);
  1146. clear_bit(Bitmap_sync, &rdev->flags);
  1147. clear_bit(WriteMostly, &rdev->flags);
  1148. if (mddev->raid_disks == 0) {
  1149. mddev->major_version = 0;
  1150. mddev->minor_version = sb->minor_version;
  1151. mddev->patch_version = sb->patch_version;
  1152. mddev->external = 0;
  1153. mddev->chunk_sectors = sb->chunk_size >> 9;
  1154. mddev->ctime = sb->ctime;
  1155. mddev->utime = sb->utime;
  1156. mddev->level = sb->level;
  1157. mddev->clevel[0] = 0;
  1158. mddev->layout = sb->layout;
  1159. mddev->raid_disks = sb->raid_disks;
  1160. mddev->dev_sectors = ((sector_t)sb->size) * 2;
  1161. mddev->events = ev1;
  1162. mddev->bitmap_info.offset = 0;
  1163. mddev->bitmap_info.space = 0;
  1164. /* bitmap can use 60 K after the 4K superblocks */
  1165. mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
  1166. mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
  1167. mddev->reshape_backwards = 0;
  1168. if (mddev->minor_version >= 91) {
  1169. mddev->reshape_position = sb->reshape_position;
  1170. mddev->delta_disks = sb->delta_disks;
  1171. mddev->new_level = sb->new_level;
  1172. mddev->new_layout = sb->new_layout;
  1173. mddev->new_chunk_sectors = sb->new_chunk >> 9;
  1174. if (mddev->delta_disks < 0)
  1175. mddev->reshape_backwards = 1;
  1176. } else {
  1177. mddev->reshape_position = MaxSector;
  1178. mddev->delta_disks = 0;
  1179. mddev->new_level = mddev->level;
  1180. mddev->new_layout = mddev->layout;
  1181. mddev->new_chunk_sectors = mddev->chunk_sectors;
  1182. }
  1183. if (mddev->level == 0)
  1184. mddev->layout = -1;
  1185. if (sb->state & (1<<MD_SB_CLEAN))
  1186. mddev->recovery_cp = MaxSector;
  1187. else {
  1188. if (sb->events_hi == sb->cp_events_hi &&
  1189. sb->events_lo == sb->cp_events_lo) {
  1190. mddev->recovery_cp = sb->recovery_cp;
  1191. } else
  1192. mddev->recovery_cp = 0;
  1193. }
  1194. memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
  1195. memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
  1196. memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
  1197. memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
  1198. mddev->max_disks = MD_SB_DISKS;
  1199. if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
  1200. mddev->bitmap_info.file == NULL) {
  1201. mddev->bitmap_info.offset =
  1202. mddev->bitmap_info.default_offset;
  1203. mddev->bitmap_info.space =
  1204. mddev->bitmap_info.default_space;
  1205. }
  1206. } else if (mddev->pers == NULL) {
  1207. /* Insist on good event counter while assembling, except
  1208. * for spares (which don't need an event count) */
  1209. ++ev1;
  1210. if (sb->disks[rdev->desc_nr].state & (
  1211. (1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE)))
  1212. if (ev1 < mddev->events)
  1213. return -EINVAL;
  1214. } else if (mddev->bitmap) {
  1215. /* if adding to array with a bitmap, then we can accept an
  1216. * older device ... but not too old.
  1217. */
  1218. if (ev1 < mddev->bitmap->events_cleared)
  1219. return 0;
  1220. if (ev1 < mddev->events)
  1221. set_bit(Bitmap_sync, &rdev->flags);
  1222. } else {
  1223. if (ev1 < mddev->events)
  1224. /* just a hot-add of a new device, leave raid_disk at -1 */
  1225. return 0;
  1226. }
  1227. if (mddev->level != LEVEL_MULTIPATH) {
  1228. desc = sb->disks + rdev->desc_nr;
  1229. if (desc->state & (1<<MD_DISK_FAULTY))
  1230. set_bit(Faulty, &rdev->flags);
  1231. else if (desc->state & (1<<MD_DISK_SYNC) /* &&
  1232. desc->raid_disk < mddev->raid_disks */) {
  1233. set_bit(In_sync, &rdev->flags);
  1234. rdev->raid_disk = desc->raid_disk;
  1235. rdev->saved_raid_disk = desc->raid_disk;
  1236. } else if (desc->state & (1<<MD_DISK_ACTIVE)) {
  1237. /* active but not in sync implies recovery up to
  1238. * reshape position. We don't know exactly where
  1239. * that is, so set to zero for now */
  1240. if (mddev->minor_version >= 91) {
  1241. rdev->recovery_offset = 0;
  1242. rdev->raid_disk = desc->raid_disk;
  1243. }
  1244. }
  1245. if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
  1246. set_bit(WriteMostly, &rdev->flags);
  1247. if (desc->state & (1<<MD_DISK_FAILFAST))
  1248. set_bit(FailFast, &rdev->flags);
  1249. } else /* MULTIPATH are always insync */
  1250. set_bit(In_sync, &rdev->flags);
  1251. return 0;
  1252. }
  1253. /*
  1254. * sync_super for 0.90.0
  1255. */
  1256. static void super_90_sync(struct mddev *mddev, struct md_rdev *rdev)
  1257. {
  1258. mdp_super_t *sb;
  1259. struct md_rdev *rdev2;
  1260. int next_spare = mddev->raid_disks;
  1261. /* make rdev->sb match mddev data..
  1262. *
  1263. * 1/ zero out disks
  1264. * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare);
  1265. * 3/ any empty disks < next_spare become removed
  1266. *
  1267. * disks[0] gets initialised to REMOVED because
  1268. * we cannot be sure from other fields if it has
  1269. * been initialised or not.
  1270. */
  1271. int i;
  1272. int active=0, working=0,failed=0,spare=0,nr_disks=0;
  1273. rdev->sb_size = MD_SB_BYTES;
  1274. sb = page_address(rdev->sb_page);
  1275. memset(sb, 0, sizeof(*sb));
  1276. sb->md_magic = MD_SB_MAGIC;
  1277. sb->major_version = mddev->major_version;
  1278. sb->patch_version = mddev->patch_version;
  1279. sb->gvalid_words = 0; /* ignored */
  1280. memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
  1281. memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
  1282. memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
  1283. memcpy(&sb->set_uuid3, mddev->uuid+12,4);
  1284. sb->ctime = clamp_t(time64_t, mddev->ctime, 0, U32_MAX);
  1285. sb->level = mddev->level;
  1286. sb->size = mddev->dev_sectors / 2;
  1287. sb->raid_disks = mddev->raid_disks;
  1288. sb->md_minor = mddev->md_minor;
  1289. sb->not_persistent = 0;
  1290. sb->utime = clamp_t(time64_t, mddev->utime, 0, U32_MAX);
  1291. sb->state = 0;
  1292. sb->events_hi = (mddev->events>>32);
  1293. sb->events_lo = (u32)mddev->events;
  1294. if (mddev->reshape_position == MaxSector)
  1295. sb->minor_version = 90;
  1296. else {
  1297. sb->minor_version = 91;
  1298. sb->reshape_position = mddev->reshape_position;
  1299. sb->new_level = mddev->new_level;
  1300. sb->delta_disks = mddev->delta_disks;
  1301. sb->new_layout = mddev->new_layout;
  1302. sb->new_chunk = mddev->new_chunk_sectors << 9;
  1303. }
  1304. mddev->minor_version = sb->minor_version;
  1305. if (mddev->in_sync)
  1306. {
  1307. sb->recovery_cp = mddev->recovery_cp;
  1308. sb->cp_events_hi = (mddev->events>>32);
  1309. sb->cp_events_lo = (u32)mddev->events;
  1310. if (mddev->recovery_cp == MaxSector)
  1311. sb->state = (1<< MD_SB_CLEAN);
  1312. } else
  1313. sb->recovery_cp = 0;
  1314. sb->layout = mddev->layout;
  1315. sb->chunk_size = mddev->chunk_sectors << 9;
  1316. if (mddev->bitmap && mddev->bitmap_info.file == NULL)
  1317. sb->state |= (1<<MD_SB_BITMAP_PRESENT);
  1318. sb->disks[0].state = (1<<MD_DISK_REMOVED);
  1319. rdev_for_each(rdev2, mddev) {
  1320. mdp_disk_t *d;
  1321. int desc_nr;
  1322. int is_active = test_bit(In_sync, &rdev2->flags);
  1323. if (rdev2->raid_disk >= 0 &&
  1324. sb->minor_version >= 91)
  1325. /* we have nowhere to store the recovery_offset,
  1326. * but if it is not below the reshape_position,
  1327. * we can piggy-back on that.
  1328. */
  1329. is_active = 1;
  1330. if (rdev2->raid_disk < 0 ||
  1331. test_bit(Faulty, &rdev2->flags))
  1332. is_active = 0;
  1333. if (is_active)
  1334. desc_nr = rdev2->raid_disk;
  1335. else
  1336. desc_nr = next_spare++;
  1337. rdev2->desc_nr = desc_nr;
  1338. d = &sb->disks[rdev2->desc_nr];
  1339. nr_disks++;
  1340. d->number = rdev2->desc_nr;
  1341. d->major = MAJOR(rdev2->bdev->bd_dev);
  1342. d->minor = MINOR(rdev2->bdev->bd_dev);
  1343. if (is_active)
  1344. d->raid_disk = rdev2->raid_disk;
  1345. else
  1346. d->raid_disk = rdev2->desc_nr; /* compatibility */
  1347. if (test_bit(Faulty, &rdev2->flags))
  1348. d->state = (1<<MD_DISK_FAULTY);
  1349. else if (is_active) {
  1350. d->state = (1<<MD_DISK_ACTIVE);
  1351. if (test_bit(In_sync, &rdev2->flags))
  1352. d->state |= (1<<MD_DISK_SYNC);
  1353. active++;
  1354. working++;
  1355. } else {
  1356. d->state = 0;
  1357. spare++;
  1358. working++;
  1359. }
  1360. if (test_bit(WriteMostly, &rdev2->flags))
  1361. d->state |= (1<<MD_DISK_WRITEMOSTLY);
  1362. if (test_bit(FailFast, &rdev2->flags))
  1363. d->state |= (1<<MD_DISK_FAILFAST);
  1364. }
  1365. /* now set the "removed" and "faulty" bits on any missing devices */
  1366. for (i=0 ; i < mddev->raid_disks ; i++) {
  1367. mdp_disk_t *d = &sb->disks[i];
  1368. if (d->state == 0 && d->number == 0) {
  1369. d->number = i;
  1370. d->raid_disk = i;
  1371. d->state = (1<<MD_DISK_REMOVED);
  1372. d->state |= (1<<MD_DISK_FAULTY);
  1373. failed++;
  1374. }
  1375. }
  1376. sb->nr_disks = nr_disks;
  1377. sb->active_disks = active;
  1378. sb->working_disks = working;
  1379. sb->failed_disks = failed;
  1380. sb->spare_disks = spare;
  1381. sb->this_disk = sb->disks[rdev->desc_nr];
  1382. sb->sb_csum = calc_sb_csum(sb);
  1383. }
  1384. /*
  1385. * rdev_size_change for 0.90.0
  1386. */
  1387. static unsigned long long
  1388. super_90_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
  1389. {
  1390. if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
  1391. return 0; /* component must fit device */
  1392. if (rdev->mddev->bitmap_info.offset)
  1393. return 0; /* can't move bitmap */
  1394. rdev->sb_start = calc_dev_sboffset(rdev);
  1395. if (!num_sectors || num_sectors > rdev->sb_start)
  1396. num_sectors = rdev->sb_start;
  1397. /* Limit to 4TB as metadata cannot record more than that.
  1398. * 4TB == 2^32 KB, or 2*2^32 sectors.
  1399. */
  1400. if ((u64)num_sectors >= (2ULL << 32) && rdev->mddev->level >= 1)
  1401. num_sectors = (sector_t)(2ULL << 32) - 2;
  1402. do {
  1403. md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
  1404. rdev->sb_page);
  1405. } while (md_super_wait(rdev->mddev) < 0);
  1406. return num_sectors;
  1407. }
  1408. static int
  1409. super_90_allow_new_offset(struct md_rdev *rdev, unsigned long long new_offset)
  1410. {
  1411. /* non-zero offset changes not possible with v0.90 */
  1412. return new_offset == 0;
  1413. }
  1414. /*
  1415. * version 1 superblock
  1416. */
  1417. static __le32 calc_sb_1_csum(struct mdp_superblock_1 *sb)
  1418. {
  1419. __le32 disk_csum;
  1420. u32 csum;
  1421. unsigned long long newcsum;
  1422. int size = 256 + le32_to_cpu(sb->max_dev)*2;
  1423. __le32 *isuper = (__le32*)sb;
  1424. disk_csum = sb->sb_csum;
  1425. sb->sb_csum = 0;
  1426. newcsum = 0;
  1427. for (; size >= 4; size -= 4)
  1428. newcsum += le32_to_cpu(*isuper++);
  1429. if (size == 2)
  1430. newcsum += le16_to_cpu(*(__le16*) isuper);
  1431. csum = (newcsum & 0xffffffff) + (newcsum >> 32);
  1432. sb->sb_csum = disk_csum;
  1433. return cpu_to_le32(csum);
  1434. }
  1435. static int super_1_load(struct md_rdev *rdev, struct md_rdev *refdev, int minor_version)
  1436. {
  1437. struct mdp_superblock_1 *sb;
  1438. int ret;
  1439. sector_t sb_start;
  1440. sector_t sectors;
  1441. char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
  1442. int bmask;
  1443. bool spare_disk = true;
  1444. /*
  1445. * Calculate the position of the superblock in 512byte sectors.
  1446. * It is always aligned to a 4K boundary and
  1447. * depeding on minor_version, it can be:
  1448. * 0: At least 8K, but less than 12K, from end of device
  1449. * 1: At start of device
  1450. * 2: 4K from start of device.
  1451. */
  1452. switch(minor_version) {
  1453. case 0:
  1454. sb_start = i_size_read(rdev->bdev->bd_inode) >> 9;
  1455. sb_start -= 8*2;
  1456. sb_start &= ~(sector_t)(4*2-1);
  1457. break;
  1458. case 1:
  1459. sb_start = 0;
  1460. break;
  1461. case 2:
  1462. sb_start = 8;
  1463. break;
  1464. default:
  1465. return -EINVAL;
  1466. }
  1467. rdev->sb_start = sb_start;
  1468. /* superblock is rarely larger than 1K, but it can be larger,
  1469. * and it is safe to read 4k, so we do that
  1470. */
  1471. ret = read_disk_sb(rdev, 4096);
  1472. if (ret) return ret;
  1473. sb = page_address(rdev->sb_page);
  1474. if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
  1475. sb->major_version != cpu_to_le32(1) ||
  1476. le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
  1477. le64_to_cpu(sb->super_offset) != rdev->sb_start ||
  1478. (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
  1479. return -EINVAL;
  1480. if (calc_sb_1_csum(sb) != sb->sb_csum) {
  1481. pr_warn("md: invalid superblock checksum on %s\n",
  1482. bdevname(rdev->bdev,b));
  1483. return -EINVAL;
  1484. }
  1485. if (le64_to_cpu(sb->data_size) < 10) {
  1486. pr_warn("md: data_size too small on %s\n",
  1487. bdevname(rdev->bdev,b));
  1488. return -EINVAL;
  1489. }
  1490. if (sb->pad0 ||
  1491. sb->pad3[0] ||
  1492. memcmp(sb->pad3, sb->pad3+1, sizeof(sb->pad3) - sizeof(sb->pad3[1])))
  1493. /* Some padding is non-zero, might be a new feature */
  1494. return -EINVAL;
  1495. rdev->preferred_minor = 0xffff;
  1496. rdev->data_offset = le64_to_cpu(sb->data_offset);
  1497. rdev->new_data_offset = rdev->data_offset;
  1498. if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE) &&
  1499. (le32_to_cpu(sb->feature_map) & MD_FEATURE_NEW_OFFSET))
  1500. rdev->new_data_offset += (s32)le32_to_cpu(sb->new_offset);
  1501. atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
  1502. rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
  1503. bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
  1504. if (rdev->sb_size & bmask)
  1505. rdev->sb_size = (rdev->sb_size | bmask) + 1;
  1506. if (minor_version
  1507. && rdev->data_offset < sb_start + (rdev->sb_size/512))
  1508. return -EINVAL;
  1509. if (minor_version
  1510. && rdev->new_data_offset < sb_start + (rdev->sb_size/512))
  1511. return -EINVAL;
  1512. if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
  1513. rdev->desc_nr = -1;
  1514. else
  1515. rdev->desc_nr = le32_to_cpu(sb->dev_number);
  1516. if (!rdev->bb_page) {
  1517. rdev->bb_page = alloc_page(GFP_KERNEL);
  1518. if (!rdev->bb_page)
  1519. return -ENOMEM;
  1520. }
  1521. if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BAD_BLOCKS) &&
  1522. rdev->badblocks.count == 0) {
  1523. /* need to load the bad block list.
  1524. * Currently we limit it to one page.
  1525. */
  1526. s32 offset;
  1527. sector_t bb_sector;
  1528. __le64 *bbp;
  1529. int i;
  1530. int sectors = le16_to_cpu(sb->bblog_size);
  1531. if (sectors > (PAGE_SIZE / 512))
  1532. return -EINVAL;
  1533. offset = le32_to_cpu(sb->bblog_offset);
  1534. if (offset == 0)
  1535. return -EINVAL;
  1536. bb_sector = (long long)offset;
  1537. if (!sync_page_io(rdev, bb_sector, sectors << 9,
  1538. rdev->bb_page, REQ_OP_READ, 0, true))
  1539. return -EIO;
  1540. bbp = (__le64 *)page_address(rdev->bb_page);
  1541. rdev->badblocks.shift = sb->bblog_shift;
  1542. for (i = 0 ; i < (sectors << (9-3)) ; i++, bbp++) {
  1543. u64 bb = le64_to_cpu(*bbp);
  1544. int count = bb & (0x3ff);
  1545. u64 sector = bb >> 10;
  1546. sector <<= sb->bblog_shift;
  1547. count <<= sb->bblog_shift;
  1548. if (bb + 1 == 0)
  1549. break;
  1550. if (badblocks_set(&rdev->badblocks, sector, count, 1))
  1551. return -EINVAL;
  1552. }
  1553. } else if (sb->bblog_offset != 0)
  1554. rdev->badblocks.shift = 0;
  1555. if ((le32_to_cpu(sb->feature_map) &
  1556. (MD_FEATURE_PPL | MD_FEATURE_MULTIPLE_PPLS))) {
  1557. rdev->ppl.offset = (__s16)le16_to_cpu(sb->ppl.offset);
  1558. rdev->ppl.size = le16_to_cpu(sb->ppl.size);
  1559. rdev->ppl.sector = rdev->sb_start + rdev->ppl.offset;
  1560. }
  1561. if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RAID0_LAYOUT) &&
  1562. sb->level != 0)
  1563. return -EINVAL;
  1564. /* not spare disk, or LEVEL_MULTIPATH */
  1565. if (sb->level == cpu_to_le32(LEVEL_MULTIPATH) ||
  1566. (rdev->desc_nr >= 0 &&
  1567. rdev->desc_nr < le32_to_cpu(sb->max_dev) &&
  1568. (le16_to_cpu(sb->dev_roles[rdev->desc_nr]) < MD_DISK_ROLE_MAX ||
  1569. le16_to_cpu(sb->dev_roles[rdev->desc_nr]) == MD_DISK_ROLE_JOURNAL)))
  1570. spare_disk = false;
  1571. if (!refdev) {
  1572. if (!spare_disk)
  1573. ret = 1;
  1574. else
  1575. ret = 0;
  1576. } else {
  1577. __u64 ev1, ev2;
  1578. struct mdp_superblock_1 *refsb = page_address(refdev->sb_page);
  1579. if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 ||
  1580. sb->level != refsb->level ||
  1581. sb->layout != refsb->layout ||
  1582. sb->chunksize != refsb->chunksize) {
  1583. pr_warn("md: %s has strangely different superblock to %s\n",
  1584. bdevname(rdev->bdev,b),
  1585. bdevname(refdev->bdev,b2));
  1586. return -EINVAL;
  1587. }
  1588. ev1 = le64_to_cpu(sb->events);
  1589. ev2 = le64_to_cpu(refsb->events);
  1590. if (!spare_disk && ev1 > ev2)
  1591. ret = 1;
  1592. else
  1593. ret = 0;
  1594. }
  1595. if (minor_version) {
  1596. sectors = (i_size_read(rdev->bdev->bd_inode) >> 9);
  1597. sectors -= rdev->data_offset;
  1598. } else
  1599. sectors = rdev->sb_start;
  1600. if (sectors < le64_to_cpu(sb->data_size))
  1601. return -EINVAL;
  1602. rdev->sectors = le64_to_cpu(sb->data_size);
  1603. return ret;
  1604. }
  1605. static int super_1_validate(struct mddev *mddev, struct md_rdev *rdev)
  1606. {
  1607. struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
  1608. __u64 ev1 = le64_to_cpu(sb->events);
  1609. rdev->raid_disk = -1;
  1610. clear_bit(Faulty, &rdev->flags);
  1611. clear_bit(In_sync, &rdev->flags);
  1612. clear_bit(Bitmap_sync, &rdev->flags);
  1613. clear_bit(WriteMostly, &rdev->flags);
  1614. if (mddev->raid_disks == 0) {
  1615. mddev->major_version = 1;
  1616. mddev->patch_version = 0;
  1617. mddev->external = 0;
  1618. mddev->chunk_sectors = le32_to_cpu(sb->chunksize);
  1619. mddev->ctime = le64_to_cpu(sb->ctime);
  1620. mddev->utime = le64_to_cpu(sb->utime);
  1621. mddev->level = le32_to_cpu(sb->level);
  1622. mddev->clevel[0] = 0;
  1623. mddev->layout = le32_to_cpu(sb->layout);
  1624. mddev->raid_disks = le32_to_cpu(sb->raid_disks);
  1625. mddev->dev_sectors = le64_to_cpu(sb->size);
  1626. mddev->events = ev1;
  1627. mddev->bitmap_info.offset = 0;
  1628. mddev->bitmap_info.space = 0;
  1629. /* Default location for bitmap is 1K after superblock
  1630. * using 3K - total of 4K
  1631. */
  1632. mddev->bitmap_info.default_offset = 1024 >> 9;
  1633. mddev->bitmap_info.default_space = (4096-1024) >> 9;
  1634. mddev->reshape_backwards = 0;
  1635. mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
  1636. memcpy(mddev->uuid, sb->set_uuid, 16);
  1637. mddev->max_disks = (4096-256)/2;
  1638. if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
  1639. mddev->bitmap_info.file == NULL) {
  1640. mddev->bitmap_info.offset =
  1641. (__s32)le32_to_cpu(sb->bitmap_offset);
  1642. /* Metadata doesn't record how much space is available.
  1643. * For 1.0, we assume we can use up to the superblock
  1644. * if before, else to 4K beyond superblock.
  1645. * For others, assume no change is possible.
  1646. */
  1647. if (mddev->minor_version > 0)
  1648. mddev->bitmap_info.space = 0;
  1649. else if (mddev->bitmap_info.offset > 0)
  1650. mddev->bitmap_info.space =
  1651. 8 - mddev->bitmap_info.offset;
  1652. else
  1653. mddev->bitmap_info.space =
  1654. -mddev->bitmap_info.offset;
  1655. }
  1656. if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
  1657. mddev->reshape_position = le64_to_cpu(sb->reshape_position);
  1658. mddev->delta_disks = le32_to_cpu(sb->delta_disks);
  1659. mddev->new_level = le32_to_cpu(sb->new_level);
  1660. mddev->new_layout = le32_to_cpu(sb->new_layout);
  1661. mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);
  1662. if (mddev->delta_disks < 0 ||
  1663. (mddev->delta_disks == 0 &&
  1664. (le32_to_cpu(sb->feature_map)
  1665. & MD_FEATURE_RESHAPE_BACKWARDS)))
  1666. mddev->reshape_backwards = 1;
  1667. } else {
  1668. mddev->reshape_position = MaxSector;
  1669. mddev->delta_disks = 0;
  1670. mddev->new_level = mddev->level;
  1671. mddev->new_layout = mddev->layout;
  1672. mddev->new_chunk_sectors = mddev->chunk_sectors;
  1673. }
  1674. if (mddev->level == 0 &&
  1675. !(le32_to_cpu(sb->feature_map) & MD_FEATURE_RAID0_LAYOUT))
  1676. mddev->layout = -1;
  1677. if (le32_to_cpu(sb->feature_map) & MD_FEATURE_JOURNAL)
  1678. set_bit(MD_HAS_JOURNAL, &mddev->flags);
  1679. if (le32_to_cpu(sb->feature_map) &
  1680. (MD_FEATURE_PPL | MD_FEATURE_MULTIPLE_PPLS)) {
  1681. if (le32_to_cpu(sb->feature_map) &
  1682. (MD_FEATURE_BITMAP_OFFSET | MD_FEATURE_JOURNAL))
  1683. return -EINVAL;
  1684. if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_PPL) &&
  1685. (le32_to_cpu(sb->feature_map) &
  1686. MD_FEATURE_MULTIPLE_PPLS))
  1687. return -EINVAL;
  1688. set_bit(MD_HAS_PPL, &mddev->flags);
  1689. }
  1690. } else if (mddev->pers == NULL) {
  1691. /* Insist of good event counter while assembling, except for
  1692. * spares (which don't need an event count) */
  1693. ++ev1;
  1694. if (rdev->desc_nr >= 0 &&
  1695. rdev->desc_nr < le32_to_cpu(sb->max_dev) &&
  1696. (le16_to_cpu(sb->dev_roles[rdev->desc_nr]) < MD_DISK_ROLE_MAX ||
  1697. le16_to_cpu(sb->dev_roles[rdev->desc_nr]) == MD_DISK_ROLE_JOURNAL))
  1698. if (ev1 < mddev->events)
  1699. return -EINVAL;
  1700. } else if (mddev->bitmap) {
  1701. /* If adding to array with a bitmap, then we can accept an
  1702. * older device, but not too old.
  1703. */
  1704. if (ev1 < mddev->bitmap->events_cleared)
  1705. return 0;
  1706. if (ev1 < mddev->events)
  1707. set_bit(Bitmap_sync, &rdev->flags);
  1708. } else {
  1709. if (ev1 < mddev->events)
  1710. /* just a hot-add of a new device, leave raid_disk at -1 */
  1711. return 0;
  1712. }
  1713. if (mddev->level != LEVEL_MULTIPATH) {
  1714. int role;
  1715. if (rdev->desc_nr < 0 ||
  1716. rdev->desc_nr >= le32_to_cpu(sb->max_dev)) {
  1717. role = MD_DISK_ROLE_SPARE;
  1718. rdev->desc_nr = -1;
  1719. } else
  1720. role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
  1721. switch(role) {
  1722. case MD_DISK_ROLE_SPARE: /* spare */
  1723. break;
  1724. case MD_DISK_ROLE_FAULTY: /* faulty */
  1725. set_bit(Faulty, &rdev->flags);
  1726. break;
  1727. case MD_DISK_ROLE_JOURNAL: /* journal device */
  1728. if (!(le32_to_cpu(sb->feature_map) & MD_FEATURE_JOURNAL)) {
  1729. /* journal device without journal feature */
  1730. pr_warn("md: journal device provided without journal feature, ignoring the device\n");
  1731. return -EINVAL;
  1732. }
  1733. set_bit(Journal, &rdev->flags);
  1734. rdev->journal_tail = le64_to_cpu(sb->journal_tail);
  1735. rdev->raid_disk = 0;
  1736. break;
  1737. default:
  1738. rdev->saved_raid_disk = role;
  1739. if ((le32_to_cpu(sb->feature_map) &
  1740. MD_FEATURE_RECOVERY_OFFSET)) {
  1741. rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
  1742. if (!(le32_to_cpu(sb->feature_map) &
  1743. MD_FEATURE_RECOVERY_BITMAP))
  1744. rdev->saved_raid_disk = -1;
  1745. } else {
  1746. /*
  1747. * If the array is FROZEN, then the device can't
  1748. * be in_sync with rest of array.
  1749. */
  1750. if (!test_bit(MD_RECOVERY_FROZEN,
  1751. &mddev->recovery))
  1752. set_bit(In_sync, &rdev->flags);
  1753. }
  1754. rdev->raid_disk = role;
  1755. break;
  1756. }
  1757. if (sb->devflags & WriteMostly1)
  1758. set_bit(WriteMostly, &rdev->flags);
  1759. if (sb->devflags & FailFast1)
  1760. set_bit(FailFast, &rdev->flags);
  1761. if (le32_to_cpu(sb->feature_map) & MD_FEATURE_REPLACEMENT)
  1762. set_bit(Replacement, &rdev->flags);
  1763. } else /* MULTIPATH are always insync */
  1764. set_bit(In_sync, &rdev->flags);
  1765. return 0;
  1766. }
  1767. static void super_1_sync(struct mddev *mddev, struct md_rdev *rdev)
  1768. {
  1769. struct mdp_superblock_1 *sb;
  1770. struct md_rdev *rdev2;
  1771. int max_dev, i;
  1772. /* make rdev->sb match mddev and rdev data. */
  1773. sb = page_address(rdev->sb_page);
  1774. sb->feature_map = 0;
  1775. sb->pad0 = 0;
  1776. sb->recovery_offset = cpu_to_le64(0);
  1777. memset(sb->pad3, 0, sizeof(sb->pad3));
  1778. sb->utime = cpu_to_le64((__u64)mddev->utime);
  1779. sb->events = cpu_to_le64(mddev->events);
  1780. if (mddev->in_sync)
  1781. sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
  1782. else if (test_bit(MD_JOURNAL_CLEAN, &mddev->flags))
  1783. sb->resync_offset = cpu_to_le64(MaxSector);
  1784. else
  1785. sb->resync_offset = cpu_to_le64(0);
  1786. sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors));
  1787. sb->raid_disks = cpu_to_le32(mddev->raid_disks);
  1788. sb->size = cpu_to_le64(mddev->dev_sectors);
  1789. sb->chunksize = cpu_to_le32(mddev->chunk_sectors);
  1790. sb->level = cpu_to_le32(mddev->level);
  1791. sb->layout = cpu_to_le32(mddev->layout);
  1792. if (test_bit(FailFast, &rdev->flags))
  1793. sb->devflags |= FailFast1;
  1794. else
  1795. sb->devflags &= ~FailFast1;
  1796. if (test_bit(WriteMostly, &rdev->flags))
  1797. sb->devflags |= WriteMostly1;
  1798. else
  1799. sb->devflags &= ~WriteMostly1;
  1800. sb->data_offset = cpu_to_le64(rdev->data_offset);
  1801. sb->data_size = cpu_to_le64(rdev->sectors);
  1802. if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
  1803. sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
  1804. sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
  1805. }
  1806. if (rdev->raid_disk >= 0 && !test_bit(Journal, &rdev->flags) &&
  1807. !test_bit(In_sync, &rdev->flags)) {
  1808. sb->feature_map |=
  1809. cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
  1810. sb->recovery_offset =
  1811. cpu_to_le64(rdev->recovery_offset);
  1812. if (rdev->saved_raid_disk >= 0 && mddev->bitmap)
  1813. sb->feature_map |=
  1814. cpu_to_le32(MD_FEATURE_RECOVERY_BITMAP);
  1815. }
  1816. /* Note: recovery_offset and journal_tail share space */
  1817. if (test_bit(Journal, &rdev->flags))
  1818. sb->journal_tail = cpu_to_le64(rdev->journal_tail);
  1819. if (test_bit(Replacement, &rdev->flags))
  1820. sb->feature_map |=
  1821. cpu_to_le32(MD_FEATURE_REPLACEMENT);
  1822. if (mddev->reshape_position != MaxSector) {
  1823. sb->feature_map |= cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE);
  1824. sb->reshape_position = cpu_to_le64(mddev->reshape_position);
  1825. sb->new_layout = cpu_to_le32(mddev->new_layout);
  1826. sb->delta_disks = cpu_to_le32(mddev->delta_disks);
  1827. sb->new_level = cpu_to_le32(mddev->new_level);
  1828. sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors);
  1829. if (mddev->delta_disks == 0 &&
  1830. mddev->reshape_backwards)
  1831. sb->feature_map
  1832. |= cpu_to_le32(MD_FEATURE_RESHAPE_BACKWARDS);
  1833. if (rdev->new_data_offset != rdev->data_offset) {
  1834. sb->feature_map
  1835. |= cpu_to_le32(MD_FEATURE_NEW_OFFSET);
  1836. sb->new_offset = cpu_to_le32((__u32)(rdev->new_data_offset
  1837. - rdev->data_offset));
  1838. }
  1839. }
  1840. if (mddev_is_clustered(mddev))
  1841. sb->feature_map |= cpu_to_le32(MD_FEATURE_CLUSTERED);
  1842. if (rdev->badblocks.count == 0)
  1843. /* Nothing to do for bad blocks*/ ;
  1844. else if (sb->bblog_offset == 0)
  1845. /* Cannot record bad blocks on this device */
  1846. md_error(mddev, rdev);
  1847. else {
  1848. struct badblocks *bb = &rdev->badblocks;
  1849. __le64 *bbp = (__le64 *)page_address(rdev->bb_page);
  1850. u64 *p = bb->page;
  1851. sb->feature_map |= cpu_to_le32(MD_FEATURE_BAD_BLOCKS);
  1852. if (bb->changed) {
  1853. unsigned seq;
  1854. retry:
  1855. seq = read_seqbegin(&bb->lock);
  1856. memset(bbp, 0xff, PAGE_SIZE);
  1857. for (i = 0 ; i < bb->count ; i++) {
  1858. u64 internal_bb = p[i];
  1859. u64 store_bb = ((BB_OFFSET(internal_bb) << 10)
  1860. | BB_LEN(internal_bb));
  1861. bbp[i] = cpu_to_le64(store_bb);
  1862. }
  1863. bb->changed = 0;
  1864. if (read_seqretry(&bb->lock, seq))
  1865. goto retry;
  1866. bb->sector = (rdev->sb_start +
  1867. (int)le32_to_cpu(sb->bblog_offset));
  1868. bb->size = le16_to_cpu(sb->bblog_size);
  1869. }
  1870. }
  1871. max_dev = 0;
  1872. rdev_for_each(rdev2, mddev)
  1873. if (rdev2->desc_nr+1 > max_dev)
  1874. max_dev = rdev2->desc_nr+1;
  1875. if (max_dev > le32_to_cpu(sb->max_dev)) {
  1876. int bmask;
  1877. sb->max_dev = cpu_to_le32(max_dev);
  1878. rdev->sb_size = max_dev * 2 + 256;
  1879. bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
  1880. if (rdev->sb_size & bmask)
  1881. rdev->sb_size = (rdev->sb_size | bmask) + 1;
  1882. } else
  1883. max_dev = le32_to_cpu(sb->max_dev);
  1884. for (i=0; i<max_dev;i++)
  1885. sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_SPARE);
  1886. if (test_bit(MD_HAS_JOURNAL, &mddev->flags))
  1887. sb->feature_map |= cpu_to_le32(MD_FEATURE_JOURNAL);
  1888. if (test_bit(MD_HAS_PPL, &mddev->flags)) {
  1889. if (test_bit(MD_HAS_MULTIPLE_PPLS, &mddev->flags))
  1890. sb->feature_map |=
  1891. cpu_to_le32(MD_FEATURE_MULTIPLE_PPLS);
  1892. else
  1893. sb->feature_map |= cpu_to_le32(MD_FEATURE_PPL);
  1894. sb->ppl.offset = cpu_to_le16(rdev->ppl.offset);
  1895. sb->ppl.size = cpu_to_le16(rdev->ppl.size);
  1896. }
  1897. rdev_for_each(rdev2, mddev) {
  1898. i = rdev2->desc_nr;
  1899. if (test_bit(Faulty, &rdev2->flags))
  1900. sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_FAULTY);
  1901. else if (test_bit(In_sync, &rdev2->flags))
  1902. sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
  1903. else if (test_bit(Journal, &rdev2->flags))
  1904. sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_JOURNAL);
  1905. else if (rdev2->raid_disk >= 0)
  1906. sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
  1907. else
  1908. sb->dev_roles[i] = cpu_to_le16(MD_DISK_ROLE_SPARE);
  1909. }
  1910. sb->sb_csum = calc_sb_1_csum(sb);
  1911. }
  1912. static sector_t super_1_choose_bm_space(sector_t dev_size)
  1913. {
  1914. sector_t bm_space;
  1915. /* if the device is bigger than 8Gig, save 64k for bitmap
  1916. * usage, if bigger than 200Gig, save 128k
  1917. */
  1918. if (dev_size < 64*2)
  1919. bm_space = 0;
  1920. else if (dev_size - 64*2 >= 200*1024*1024*2)
  1921. bm_space = 128*2;
  1922. else if (dev_size - 4*2 > 8*1024*1024*2)
  1923. bm_space = 64*2;
  1924. else
  1925. bm_space = 4*2;
  1926. return bm_space;
  1927. }
  1928. static unsigned long long
  1929. super_1_rdev_size_change(struct md_rdev *rdev, sector_t num_sectors)
  1930. {
  1931. struct mdp_superblock_1 *sb;
  1932. sector_t max_sectors;
  1933. if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
  1934. return 0; /* component must fit device */
  1935. if (rdev->data_offset != rdev->new_data_offset)
  1936. return 0; /* too confusing */
  1937. if (rdev->sb_start < rdev->data_offset) {
  1938. /* minor versions 1 and 2; superblock before data */
  1939. max_sectors = i_size_read(rdev->bdev->bd_inode) >> 9;
  1940. max_sectors -= rdev->data_offset;
  1941. if (!num_sectors || num_sectors > max_sectors)
  1942. num_sectors = max_sectors;
  1943. } else if (rdev->mddev->bitmap_info.offset) {
  1944. /* minor version 0 with bitmap we can't move */
  1945. return 0;
  1946. } else {
  1947. /* minor version 0; superblock after data */
  1948. sector_t sb_start, bm_space;
  1949. sector_t dev_size = i_size_read(rdev->bdev->bd_inode) >> 9;
  1950. /* 8K is for superblock */
  1951. sb_start = dev_size - 8*2;
  1952. sb_start &= ~(sector_t)(4*2 - 1);
  1953. bm_space = super_1_choose_bm_space(dev_size);
  1954. /* Space that can be used to store date needs to decrease
  1955. * superblock bitmap space and bad block space(4K)
  1956. */
  1957. max_sectors = sb_start - bm_space - 4*2;
  1958. if (!num_sectors || num_sectors > max_sectors)
  1959. num_sectors = max_sectors;
  1960. rdev->sb_start = sb_start;
  1961. }
  1962. sb = page_address(rdev->sb_page);
  1963. sb->data_size = cpu_to_le64(num_sectors);
  1964. sb->super_offset = cpu_to_le64(rdev->sb_start);
  1965. sb->sb_csum = calc_sb_1_csum(sb);
  1966. do {
  1967. md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
  1968. rdev->sb_page);
  1969. } while (md_super_wait(rdev->mddev) < 0);
  1970. return num_sectors;
  1971. }
  1972. static int
  1973. super_1_allow_new_offset(struct md_rdev *rdev,
  1974. unsigned long long new_offset)
  1975. {
  1976. /* All necessary checks on new >= old have been done */
  1977. struct bitmap *bitmap;
  1978. if (new_offset >= rdev->data_offset)
  1979. return 1;
  1980. /* with 1.0 metadata, there is no metadata to tread on
  1981. * so we can always move back */
  1982. if (rdev->mddev->minor_version == 0)
  1983. return 1;
  1984. /* otherwise we must be sure not to step on
  1985. * any metadata, so stay:
  1986. * 36K beyond start of superblock
  1987. * beyond end of badblocks
  1988. * beyond write-intent bitmap
  1989. */
  1990. if (rdev->sb_start + (32+4)*2 > new_offset)
  1991. return 0;
  1992. bitmap = rdev->mddev->bitmap;
  1993. if (bitmap && !rdev->mddev->bitmap_info.file &&
  1994. rdev->sb_start + rdev->mddev->bitmap_info.offset +
  1995. bitmap->storage.file_pages * (PAGE_SIZE>>9) > new_offset)
  1996. return 0;
  1997. if (rdev->badblocks.sector + rdev->badblocks.size > new_offset)
  1998. return 0;
  1999. return 1;
  2000. }
  2001. static struct super_type super_types[] = {
  2002. [0] = {
  2003. .name = "0.90.0",
  2004. .owner = THIS_MODULE,
  2005. .load_super = super_90_load,
  2006. .validate_super = super_90_validate,
  2007. .sync_super = super_90_sync,
  2008. .rdev_size_change = super_90_rdev_size_change,
  2009. .allow_new_offset = super_90_allow_new_offset,
  2010. },
  2011. [1] = {
  2012. .name = "md-1",
  2013. .owner = THIS_MODULE,
  2014. .load_super = super_1_load,
  2015. .validate_super = super_1_validate,
  2016. .sync_super = super_1_sync,
  2017. .rdev_size_change = super_1_rdev_size_change,
  2018. .allow_new_offset = super_1_allow_new_offset,
  2019. },
  2020. };
  2021. static void sync_super(struct mddev *mddev, struct md_rdev *rdev)
  2022. {
  2023. if (mddev->sync_super) {
  2024. mddev->sync_super(mddev, rdev);
  2025. return;
  2026. }
  2027. BUG_ON(mddev->major_version >= ARRAY_SIZE(super_types));
  2028. super_types[mddev->major_version].sync_super(mddev, rdev);
  2029. }
  2030. static int match_mddev_units(struct mddev *mddev1, struct mddev *mddev2)
  2031. {
  2032. struct md_rdev *rdev, *rdev2;
  2033. rcu_read_lock();
  2034. rdev_for_each_rcu(rdev, mddev1) {
  2035. if (test_bit(Faulty, &rdev->flags) ||
  2036. test_bit(Journal, &rdev->flags) ||
  2037. rdev->raid_disk == -1)
  2038. continue;
  2039. rdev_for_each_rcu(rdev2, mddev2) {
  2040. if (test_bit(Faulty, &rdev2->flags) ||
  2041. test_bit(Journal, &rdev2->flags) ||
  2042. rdev2->raid_disk == -1)
  2043. continue;
  2044. if (rdev->bdev->bd_disk == rdev2->bdev->bd_disk) {
  2045. rcu_read_unlock();
  2046. return 1;
  2047. }
  2048. }
  2049. }
  2050. rcu_read_unlock();
  2051. return 0;
  2052. }
  2053. static LIST_HEAD(pending_raid_disks);
  2054. /*
  2055. * Try to register data integrity profile for an mddev
  2056. *
  2057. * This is called when an array is started and after a disk has been kicked
  2058. * from the array. It only succeeds if all working and active component devices
  2059. * are integrity capable with matching profiles.
  2060. */
  2061. int md_integrity_register(struct mddev *mddev)
  2062. {
  2063. struct md_rdev *rdev, *reference = NULL;
  2064. if (list_empty(&mddev->disks))
  2065. return 0; /* nothing to do */
  2066. if (!mddev->gendisk || blk_get_integrity(mddev->gendisk))
  2067. return 0; /* shouldn't register, or already is */
  2068. rdev_for_each(rdev, mddev) {
  2069. /* skip spares and non-functional disks */
  2070. if (test_bit(Faulty, &rdev->flags))
  2071. continue;
  2072. if (rdev->raid_disk < 0)
  2073. continue;
  2074. if (!reference) {
  2075. /* Use the first rdev as the reference */
  2076. reference = rdev;
  2077. continue;
  2078. }
  2079. /* does this rdev's profile match the reference profile? */
  2080. if (blk_integrity_compare(reference->bdev->bd_disk,
  2081. rdev->bdev->bd_disk) < 0)
  2082. return -EINVAL;
  2083. }
  2084. if (!reference || !bdev_get_integrity(reference->bdev))
  2085. return 0;
  2086. /*
  2087. * All component devices are integrity capable and have matching
  2088. * profiles, register the common profile for the md device.
  2089. */
  2090. blk_integrity_register(mddev->gendisk,
  2091. bdev_get_integrity(reference->bdev));
  2092. pr_debug("md: data integrity enabled on %s\n", mdname(mddev));
  2093. if (bioset_integrity_create(&mddev->bio_set, BIO_POOL_SIZE)) {
  2094. pr_err("md: failed to create integrity pool for %s\n",
  2095. mdname(mddev));
  2096. return -EINVAL;
  2097. }
  2098. return 0;
  2099. }
  2100. EXPORT_SYMBOL(md_integrity_register);
  2101. /*
  2102. * Attempt to add an rdev, but only if it is consistent with the current
  2103. * integrity profile
  2104. */
  2105. int md_integrity_add_rdev(struct md_rdev *rdev, struct mddev *mddev)
  2106. {
  2107. struct blk_integrity *bi_mddev;
  2108. char name[BDEVNAME_SIZE];
  2109. if (!mddev->gendisk)
  2110. return 0;
  2111. bi_mddev = blk_get_integrity(mddev->gendisk);
  2112. if (!bi_mddev) /* nothing to do */
  2113. return 0;
  2114. if (blk_integrity_compare(mddev->gendisk, rdev->bdev->bd_disk) != 0) {
  2115. pr_err("%s: incompatible integrity profile for %s\n",
  2116. mdname(mddev), bdevname(rdev->bdev, name));
  2117. return -ENXIO;
  2118. }
  2119. return 0;
  2120. }
  2121. EXPORT_SYMBOL(md_integrity_add_rdev);
  2122. static int bind_rdev_to_array(struct md_rdev *rdev, struct mddev *mddev)
  2123. {
  2124. char b[BDEVNAME_SIZE];
  2125. struct kobject *ko;
  2126. int err;
  2127. /* prevent duplicates */
  2128. if (find_rdev(mddev, rdev->bdev->bd_dev))
  2129. return -EEXIST;
  2130. if ((bdev_read_only(rdev->bdev) || bdev_read_only(rdev->meta_bdev)) &&
  2131. mddev->pers)
  2132. return -EROFS;
  2133. /* make sure rdev->sectors exceeds mddev->dev_sectors */
  2134. if (!test_bit(Journal, &rdev->flags) &&
  2135. rdev->sectors &&
  2136. (mddev->dev_sectors == 0 || rdev->sectors < mddev->dev_sectors)) {
  2137. if (mddev->pers) {
  2138. /* Cannot change size, so fail
  2139. * If mddev->level <= 0, then we don't care
  2140. * about aligning sizes (e.g. linear)
  2141. */
  2142. if (mddev->level > 0)
  2143. return -ENOSPC;
  2144. } else
  2145. mddev->dev_sectors = rdev->sectors;
  2146. }
  2147. /* Verify rdev->desc_nr is unique.
  2148. * If it is -1, assign a free number, else
  2149. * check number is not in use
  2150. */
  2151. rcu_read_lock();
  2152. if (rdev->desc_nr < 0) {
  2153. int choice = 0;
  2154. if (mddev->pers)
  2155. choice = mddev->raid_disks;
  2156. while (md_find_rdev_nr_rcu(mddev, choice))
  2157. choice++;
  2158. rdev->desc_nr = choice;
  2159. } else {
  2160. if (md_find_rdev_nr_rcu(mddev, rdev->desc_nr)) {
  2161. rcu_read_unlock();
  2162. return -EBUSY;
  2163. }
  2164. }
  2165. rcu_read_unlock();
  2166. if (!test_bit(Journal, &rdev->flags) &&
  2167. mddev->max_disks && rdev->desc_nr >= mddev->max_disks) {
  2168. pr_warn("md: %s: array is limited to %d devices\n",
  2169. mdname(mddev), mddev->max_disks);
  2170. return -EBUSY;
  2171. }
  2172. bdevname(rdev->bdev,b);
  2173. strreplace(b, '/', '!');
  2174. rdev->mddev = mddev;
  2175. pr_debug("md: bind<%s>\n", b);
  2176. if (mddev->raid_disks)
  2177. mddev_create_serial_pool(mddev, rdev, false);
  2178. if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
  2179. goto fail;
  2180. ko = &part_to_dev(rdev->bdev->bd_part)->kobj;
  2181. /* failure here is OK */
  2182. err = sysfs_create_link(&rdev->kobj, ko, "block");
  2183. rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state");
  2184. rdev->sysfs_unack_badblocks =
  2185. sysfs_get_dirent_safe(rdev->kobj.sd, "unacknowledged_bad_blocks");
  2186. rdev->sysfs_badblocks =
  2187. sysfs_get_dirent_safe(rdev->kobj.sd, "bad_blocks");
  2188. list_add_rcu(&rdev->same_set, &mddev->disks);
  2189. bd_link_disk_holder(rdev->bdev, mddev->gendisk);
  2190. /* May as well allow recovery to be retried once */
  2191. mddev->recovery_disabled++;
  2192. return 0;
  2193. fail:
  2194. pr_warn("md: failed to register dev-%s for %s\n",
  2195. b, mdname(mddev));
  2196. return err;
  2197. }
  2198. static void rdev_delayed_delete(struct work_struct *ws)
  2199. {
  2200. struct md_rdev *rdev = container_of(ws, struct md_rdev, del_work);
  2201. kobject_del(&rdev->kobj);
  2202. kobject_put(&rdev->kobj);
  2203. }
  2204. static void unbind_rdev_from_array(struct md_rdev *rdev)
  2205. {
  2206. char b[BDEVNAME_SIZE];
  2207. bd_unlink_disk_holder(rdev->bdev, rdev->mddev->gendisk);
  2208. list_del_rcu(&rdev->same_set);
  2209. pr_debug("md: unbind<%s>\n", bdevname(rdev->bdev,b));
  2210. mddev_destroy_serial_pool(rdev->mddev, rdev, false);
  2211. rdev->mddev = NULL;
  2212. sysfs_remove_link(&rdev->kobj, "block");
  2213. sysfs_put(rdev->sysfs_state);
  2214. sysfs_put(rdev->sysfs_unack_badblocks);
  2215. sysfs_put(rdev->sysfs_badblocks);
  2216. rdev->sysfs_state = NULL;
  2217. rdev->sysfs_unack_badblocks = NULL;
  2218. rdev->sysfs_badblocks = NULL;
  2219. rdev->badblocks.count = 0;
  2220. /* We need to delay this, otherwise we can deadlock when
  2221. * writing to 'remove' to "dev/state". We also need
  2222. * to delay it due to rcu usage.
  2223. */
  2224. synchronize_rcu();
  2225. INIT_WORK(&rdev->del_work, rdev_delayed_delete);
  2226. kobject_get(&rdev->kobj);
  2227. queue_work(md_rdev_misc_wq, &rdev->del_work);
  2228. }
  2229. /*
  2230. * prevent the device from being mounted, repartitioned or
  2231. * otherwise reused by a RAID array (or any other kernel
  2232. * subsystem), by bd_claiming the device.
  2233. */
  2234. static int lock_rdev(struct md_rdev *rdev, dev_t dev, int shared)
  2235. {
  2236. int err = 0;
  2237. struct block_device *bdev;
  2238. bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
  2239. shared ? (struct md_rdev *)lock_rdev : rdev);
  2240. if (IS_ERR(bdev)) {
  2241. pr_warn("md: could not open device unknown-block(%u,%u).\n",
  2242. MAJOR(dev), MINOR(dev));
  2243. return PTR_ERR(bdev);
  2244. }
  2245. rdev->bdev = bdev;
  2246. return err;
  2247. }
  2248. static void unlock_rdev(struct md_rdev *rdev)
  2249. {
  2250. struct block_device *bdev = rdev->bdev;
  2251. rdev->bdev = NULL;
  2252. blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
  2253. }
  2254. void md_autodetect_dev(dev_t dev);
  2255. static void export_rdev(struct md_rdev *rdev)
  2256. {
  2257. char b[BDEVNAME_SIZE];
  2258. pr_debug("md: export_rdev(%s)\n", bdevname(rdev->bdev,b));
  2259. md_rdev_clear(rdev);
  2260. #ifndef MODULE
  2261. if (test_bit(AutoDetected, &rdev->flags))
  2262. md_autodetect_dev(rdev->bdev->bd_dev);
  2263. #endif
  2264. unlock_rdev(rdev);
  2265. kobject_put(&rdev->kobj);
  2266. }
  2267. void md_kick_rdev_from_array(struct md_rdev *rdev)
  2268. {
  2269. unbind_rdev_from_array(rdev);
  2270. export_rdev(rdev);
  2271. }
  2272. EXPORT_SYMBOL_GPL(md_kick_rdev_from_array);
  2273. static void export_array(struct mddev *mddev)
  2274. {
  2275. struct md_rdev *rdev;
  2276. while (!list_empty(&mddev->disks)) {
  2277. rdev = list_first_entry(&mddev->disks, struct md_rdev,
  2278. same_set);
  2279. md_kick_rdev_from_array(rdev);
  2280. }
  2281. mddev->raid_disks = 0;
  2282. mddev->major_version = 0;
  2283. }
  2284. static bool set_in_sync(struct mddev *mddev)
  2285. {
  2286. lockdep_assert_held(&mddev->lock);
  2287. if (!mddev->in_sync) {
  2288. mddev->sync_checkers++;
  2289. spin_unlock(&mddev->lock);
  2290. percpu_ref_switch_to_atomic_sync(&mddev->writes_pending);
  2291. spin_lock(&mddev->lock);
  2292. if (!mddev->in_sync &&
  2293. percpu_ref_is_zero(&mddev->writes_pending)) {
  2294. mddev->in_sync = 1;
  2295. /*
  2296. * Ensure ->in_sync is visible before we clear
  2297. * ->sync_checkers.
  2298. */
  2299. smp_mb();
  2300. set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
  2301. sysfs_notify_dirent_safe(mddev->sysfs_state);
  2302. }
  2303. if (--mddev->sync_checkers == 0)
  2304. percpu_ref_switch_to_percpu(&mddev->writes_pending);
  2305. }
  2306. if (mddev->safemode == 1)
  2307. mddev->safemode = 0;
  2308. return mddev->in_sync;
  2309. }
  2310. static void sync_sbs(struct mddev *mddev, int nospares)
  2311. {
  2312. /* Update each superblock (in-memory image), but
  2313. * if we are allowed to, skip spares which already
  2314. * have the right event counter, or have one earlier
  2315. * (which would mean they aren't being marked as dirty
  2316. * with the rest of the array)
  2317. */
  2318. struct md_rdev *rdev;
  2319. rdev_for_each(rdev, mddev) {
  2320. if (rdev->sb_events == mddev->events ||
  2321. (nospares &&
  2322. rdev->raid_disk < 0 &&
  2323. rdev->sb_events+1 == mddev->events)) {
  2324. /* Don't update this superblock */
  2325. rdev->sb_loaded = 2;
  2326. } else {
  2327. sync_super(mddev, rdev);
  2328. rdev->sb_loaded = 1;
  2329. }
  2330. }
  2331. }
  2332. static bool does_sb_need_changing(struct mddev *mddev)
  2333. {
  2334. struct md_rdev *rdev;
  2335. struct mdp_superblock_1 *sb;
  2336. int role;
  2337. /* Find a good rdev */
  2338. rdev_for_each(rdev, mddev)
  2339. if ((rdev->raid_disk >= 0) && !test_bit(Faulty, &rdev->flags))
  2340. break;
  2341. /* No good device found. */
  2342. if (!rdev)
  2343. return false;
  2344. sb = page_address(rdev->sb_page);
  2345. /* Check if a device has become faulty or a spare become active */
  2346. rdev_for_each(rdev, mddev) {
  2347. role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
  2348. /* Device activated? */
  2349. if (role == 0xffff && rdev->raid_disk >=0 &&
  2350. !test_bit(Faulty, &rdev->flags))
  2351. return true;
  2352. /* Device turned faulty? */
  2353. if (test_bit(Faulty, &rdev->flags) && (role < 0xfffd))
  2354. return true;
  2355. }
  2356. /* Check if any mddev parameters have changed */
  2357. if ((mddev->dev_sectors != le64_to_cpu(sb->size)) ||
  2358. (mddev->reshape_position != le64_to_cpu(sb->reshape_position)) ||
  2359. (mddev->layout != le32_to_cpu(sb->layout)) ||
  2360. (mddev->raid_disks != le32_to_cpu(sb->raid_disks)) ||
  2361. (mddev->chunk_sectors != le32_to_cpu(sb->chunksize)))
  2362. return true;
  2363. return false;
  2364. }
  2365. void md_update_sb(struct mddev *mddev, int force_change)
  2366. {
  2367. struct md_rdev *rdev;
  2368. int sync_req;
  2369. int nospares = 0;
  2370. int any_badblocks_changed = 0;
  2371. int ret = -1;
  2372. if (mddev->ro) {
  2373. if (force_change)
  2374. set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
  2375. return;
  2376. }
  2377. repeat:
  2378. if (mddev_is_clustered(mddev)) {
  2379. if (test_and_clear_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags))
  2380. force_change = 1;
  2381. if (test_and_clear_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags))
  2382. nospares = 1;
  2383. ret = md_cluster_ops->metadata_update_start(mddev);
  2384. /* Has someone else has updated the sb */
  2385. if (!does_sb_need_changing(mddev)) {
  2386. if (ret == 0)
  2387. md_cluster_ops->metadata_update_cancel(mddev);
  2388. bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING),
  2389. BIT(MD_SB_CHANGE_DEVS) |
  2390. BIT(MD_SB_CHANGE_CLEAN));
  2391. return;
  2392. }
  2393. }
  2394. /*
  2395. * First make sure individual recovery_offsets are correct
  2396. * curr_resync_completed can only be used during recovery.
  2397. * During reshape/resync it might use array-addresses rather
  2398. * that device addresses.
  2399. */
  2400. rdev_for_each(rdev, mddev) {
  2401. if (rdev->raid_disk >= 0 &&
  2402. mddev->delta_disks >= 0 &&
  2403. test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
  2404. test_bit(MD_RECOVERY_RECOVER, &mddev->recovery) &&
  2405. !test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
  2406. !test_bit(Journal, &rdev->flags) &&
  2407. !test_bit(In_sync, &rdev->flags) &&
  2408. mddev->curr_resync_completed > rdev->recovery_offset)
  2409. rdev->recovery_offset = mddev->curr_resync_completed;
  2410. }
  2411. if (!mddev->persistent) {
  2412. clear_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
  2413. clear_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
  2414. if (!mddev->external) {
  2415. clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
  2416. rdev_for_each(rdev, mddev) {
  2417. if (rdev->badblocks.changed) {
  2418. rdev->badblocks.changed = 0;
  2419. ack_all_badblocks(&rdev->badblocks);
  2420. md_error(mddev, rdev);
  2421. }
  2422. clear_bit(Blocked, &rdev->flags);
  2423. clear_bit(BlockedBadBlocks, &rdev->flags);
  2424. wake_up(&rdev->blocked_wait);
  2425. }
  2426. }
  2427. wake_up(&mddev->sb_wait);
  2428. return;
  2429. }
  2430. spin_lock(&mddev->lock);
  2431. mddev->utime = ktime_get_real_seconds();
  2432. if (test_and_clear_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags))
  2433. force_change = 1;
  2434. if (test_and_clear_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags))
  2435. /* just a clean<-> dirty transition, possibly leave spares alone,
  2436. * though if events isn't the right even/odd, we will have to do
  2437. * spares after all
  2438. */
  2439. nospares = 1;
  2440. if (force_change)
  2441. nospares = 0;
  2442. if (mddev->degraded)
  2443. /* If the array is degraded, then skipping spares is both
  2444. * dangerous and fairly pointless.
  2445. * Dangerous because a device that was removed from the array
  2446. * might have a event_count that still looks up-to-date,
  2447. * so it can be re-added without a resync.
  2448. * Pointless because if there are any spares to skip,
  2449. * then a recovery will happen and soon that array won't
  2450. * be degraded any more and the spare can go back to sleep then.
  2451. */
  2452. nospares = 0;
  2453. sync_req = mddev->in_sync;
  2454. /* If this is just a dirty<->clean transition, and the array is clean
  2455. * and 'events' is odd, we can roll back to the previous clean state */
  2456. if (nospares
  2457. && (mddev->in_sync && mddev->recovery_cp == MaxSector)
  2458. && mddev->can_decrease_events
  2459. && mddev->events != 1) {
  2460. mddev->events--;
  2461. mddev->can_decrease_events = 0;
  2462. } else {
  2463. /* otherwise we have to go forward and ... */
  2464. mddev->events ++;
  2465. mddev->can_decrease_events = nospares;
  2466. }
  2467. /*
  2468. * This 64-bit counter should never wrap.
  2469. * Either we are in around ~1 trillion A.C., assuming
  2470. * 1 reboot per second, or we have a bug...
  2471. */
  2472. WARN_ON(mddev->events == 0);
  2473. rdev_for_each(rdev, mddev) {
  2474. if (rdev->badblocks.changed)
  2475. any_badblocks_changed++;
  2476. if (test_bit(Faulty, &rdev->flags))
  2477. set_bit(FaultRecorded, &rdev->flags);
  2478. }
  2479. sync_sbs(mddev, nospares);
  2480. spin_unlock(&mddev->lock);
  2481. pr_debug("md: updating %s RAID superblock on device (in sync %d)\n",
  2482. mdname(mddev), mddev->in_sync);
  2483. if (mddev->queue)
  2484. blk_add_trace_msg(mddev->queue, "md md_update_sb");
  2485. rewrite:
  2486. md_bitmap_update_sb(mddev->bitmap);
  2487. rdev_for_each(rdev, mddev) {
  2488. char b[BDEVNAME_SIZE];
  2489. if (rdev->sb_loaded != 1)
  2490. continue; /* no noise on spare devices */
  2491. if (!test_bit(Faulty, &rdev->flags)) {
  2492. md_super_write(mddev,rdev,
  2493. rdev->sb_start, rdev->sb_size,
  2494. rdev->sb_page);
  2495. pr_debug("md: (write) %s's sb offset: %llu\n",
  2496. bdevname(rdev->bdev, b),
  2497. (unsigned long long)rdev->sb_start);
  2498. rdev->sb_events = mddev->events;
  2499. if (rdev->badblocks.size) {
  2500. md_super_write(mddev, rdev,
  2501. rdev->badblocks.sector,
  2502. rdev->badblocks.size << 9,
  2503. rdev->bb_page);
  2504. rdev->badblocks.size = 0;
  2505. }
  2506. } else
  2507. pr_debug("md: %s (skipping faulty)\n",
  2508. bdevname(rdev->bdev, b));
  2509. if (mddev->level == LEVEL_MULTIPATH)
  2510. /* only need to write one superblock... */
  2511. break;
  2512. }
  2513. if (md_super_wait(mddev) < 0)
  2514. goto rewrite;
  2515. /* if there was a failure, MD_SB_CHANGE_DEVS was set, and we re-write super */
  2516. if (mddev_is_clustered(mddev) && ret == 0)
  2517. md_cluster_ops->metadata_update_finish(mddev);
  2518. if (mddev->in_sync != sync_req ||
  2519. !bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING),
  2520. BIT(MD_SB_CHANGE_DEVS) | BIT(MD_SB_CHANGE_CLEAN)))
  2521. /* have to write it out again */
  2522. goto repeat;
  2523. wake_up(&mddev->sb_wait);
  2524. if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
  2525. sysfs_notify_dirent_safe(mddev->sysfs_completed);
  2526. rdev_for_each(rdev, mddev) {
  2527. if (test_and_clear_bit(FaultRecorded, &rdev->flags))
  2528. clear_bit(Blocked, &rdev->flags);
  2529. if (any_badblocks_changed)
  2530. ack_all_badblocks(&rdev->badblocks);
  2531. clear_bit(BlockedBadBlocks, &rdev->flags);
  2532. wake_up(&rdev->blocked_wait);
  2533. }
  2534. }
  2535. EXPORT_SYMBOL(md_update_sb);
  2536. static int add_bound_rdev(struct md_rdev *rdev)
  2537. {
  2538. struct mddev *mddev = rdev->mddev;
  2539. int err = 0;
  2540. bool add_journal = test_bit(Journal, &rdev->flags);
  2541. if (!mddev->pers->hot_remove_disk || add_journal) {
  2542. /* If there is hot_add_disk but no hot_remove_disk
  2543. * then added disks for geometry changes,
  2544. * and should be added immediately.
  2545. */
  2546. super_types[mddev->major_version].
  2547. validate_super(mddev, rdev);
  2548. if (add_journal)
  2549. mddev_suspend(mddev);
  2550. err = mddev->pers->hot_add_disk(mddev, rdev);
  2551. if (add_journal)
  2552. mddev_resume(mddev);
  2553. if (err) {
  2554. md_kick_rdev_from_array(rdev);
  2555. return err;
  2556. }
  2557. }
  2558. sysfs_notify_dirent_safe(rdev->sysfs_state);
  2559. set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
  2560. if (mddev->degraded)
  2561. set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
  2562. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  2563. md_new_event(mddev);
  2564. md_wakeup_thread(mddev->thread);
  2565. return 0;
  2566. }
  2567. /* words written to sysfs files may, or may not, be \n terminated.
  2568. * We want to accept with case. For this we use cmd_match.
  2569. */
  2570. static int cmd_match(const char *cmd, const char *str)
  2571. {
  2572. /* See if cmd, written into a sysfs file, matches
  2573. * str. They must either be the same, or cmd can
  2574. * have a trailing newline
  2575. */
  2576. while (*cmd && *str && *cmd == *str) {
  2577. cmd++;
  2578. str++;
  2579. }
  2580. if (*cmd == '\n')
  2581. cmd++;
  2582. if (*str || *cmd)
  2583. return 0;
  2584. return 1;
  2585. }
  2586. struct rdev_sysfs_entry {
  2587. struct attribute attr;
  2588. ssize_t (*show)(struct md_rdev *, char *);
  2589. ssize_t (*store)(struct md_rdev *, const char *, size_t);
  2590. };
  2591. static ssize_t
  2592. state_show(struct md_rdev *rdev, char *page)
  2593. {
  2594. char *sep = ",";
  2595. size_t len = 0;
  2596. unsigned long flags = READ_ONCE(rdev->flags);
  2597. if (test_bit(Faulty, &flags) ||
  2598. (!test_bit(ExternalBbl, &flags) &&
  2599. rdev->badblocks.unacked_exist))
  2600. len += sprintf(page+len, "faulty%s", sep);
  2601. if (test_bit(In_sync, &flags))
  2602. len += sprintf(page+len, "in_sync%s", sep);
  2603. if (test_bit(Journal, &flags))
  2604. len += sprintf(page+len, "journal%s", sep);
  2605. if (test_bit(WriteMostly, &flags))
  2606. len += sprintf(page+len, "write_mostly%s", sep);
  2607. if (test_bit(Blocked, &flags) ||
  2608. (rdev->badblocks.unacked_exist
  2609. && !test_bit(Faulty, &flags)))
  2610. len += sprintf(page+len, "blocked%s", sep);
  2611. if (!test_bit(Faulty, &flags) &&
  2612. !test_bit(Journal, &flags) &&
  2613. !test_bit(In_sync, &flags))
  2614. len += sprintf(page+len, "spare%s", sep);
  2615. if (test_bit(WriteErrorSeen, &flags))
  2616. len += sprintf(page+len, "write_error%s", sep);
  2617. if (test_bit(WantReplacement, &flags))
  2618. len += sprintf(page+len, "want_replacement%s", sep);
  2619. if (test_bit(Replacement, &flags))
  2620. len += sprintf(page+len, "replacement%s", sep);
  2621. if (test_bit(ExternalBbl, &flags))
  2622. len += sprintf(page+len, "external_bbl%s", sep);
  2623. if (test_bit(FailFast, &flags))
  2624. len += sprintf(page+len, "failfast%s", sep);
  2625. if (len)
  2626. len -= strlen(sep);
  2627. return len+sprintf(page+len, "\n");
  2628. }
  2629. static ssize_t
  2630. state_store(struct md_rdev *rdev, const char *buf, size_t len)
  2631. {
  2632. /* can write
  2633. * faulty - simulates an error
  2634. * remove - disconnects the device
  2635. * writemostly - sets write_mostly
  2636. * -writemostly - clears write_mostly
  2637. * blocked - sets the Blocked flags
  2638. * -blocked - clears the Blocked and possibly simulates an error
  2639. * insync - sets Insync providing device isn't active
  2640. * -insync - clear Insync for a device with a slot assigned,
  2641. * so that it gets rebuilt based on bitmap
  2642. * write_error - sets WriteErrorSeen
  2643. * -write_error - clears WriteErrorSeen
  2644. * {,-}failfast - set/clear FailFast
  2645. */
  2646. struct mddev *mddev = rdev->mddev;
  2647. int err = -EINVAL;
  2648. bool need_update_sb = false;
  2649. if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
  2650. md_error(rdev->mddev, rdev);
  2651. if (test_bit(Faulty, &rdev->flags))
  2652. err = 0;
  2653. else
  2654. err = -EBUSY;
  2655. } else if (cmd_match(buf, "remove")) {
  2656. if (rdev->mddev->pers) {
  2657. clear_bit(Blocked, &rdev->flags);
  2658. remove_and_add_spares(rdev->mddev, rdev);
  2659. }
  2660. if (rdev->raid_disk >= 0)
  2661. err = -EBUSY;
  2662. else {
  2663. err = 0;
  2664. if (mddev_is_clustered(mddev))
  2665. err = md_cluster_ops->remove_disk(mddev, rdev);
  2666. if (err == 0) {
  2667. md_kick_rdev_from_array(rdev);
  2668. if (mddev->pers) {
  2669. set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
  2670. md_wakeup_thread(mddev->thread);
  2671. }
  2672. md_new_event(mddev);
  2673. }
  2674. }
  2675. } else if (cmd_match(buf, "writemostly")) {
  2676. set_bit(WriteMostly, &rdev->flags);
  2677. mddev_create_serial_pool(rdev->mddev, rdev, false);
  2678. need_update_sb = true;
  2679. err = 0;
  2680. } else if (cmd_match(buf, "-writemostly")) {
  2681. mddev_destroy_serial_pool(rdev->mddev, rdev, false);
  2682. clear_bit(WriteMostly, &rdev->flags);
  2683. need_update_sb = true;
  2684. err = 0;
  2685. } else if (cmd_match(buf, "blocked")) {
  2686. set_bit(Blocked, &rdev->flags);
  2687. err = 0;
  2688. } else if (cmd_match(buf, "-blocked")) {
  2689. if (!test_bit(Faulty, &rdev->flags) &&
  2690. !test_bit(ExternalBbl, &rdev->flags) &&
  2691. rdev->badblocks.unacked_exist) {
  2692. /* metadata handler doesn't understand badblocks,
  2693. * so we need to fail the device
  2694. */
  2695. md_error(rdev->mddev, rdev);
  2696. }
  2697. clear_bit(Blocked, &rdev->flags);
  2698. clear_bit(BlockedBadBlocks, &rdev->flags);
  2699. wake_up(&rdev->blocked_wait);
  2700. set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
  2701. md_wakeup_thread(rdev->mddev->thread);
  2702. err = 0;
  2703. } else if (cmd_match(buf, "insync") && rdev->raid_disk == -1) {
  2704. set_bit(In_sync, &rdev->flags);
  2705. err = 0;
  2706. } else if (cmd_match(buf, "failfast")) {
  2707. set_bit(FailFast, &rdev->flags);
  2708. need_update_sb = true;
  2709. err = 0;
  2710. } else if (cmd_match(buf, "-failfast")) {
  2711. clear_bit(FailFast, &rdev->flags);
  2712. need_update_sb = true;
  2713. err = 0;
  2714. } else if (cmd_match(buf, "-insync") && rdev->raid_disk >= 0 &&
  2715. !test_bit(Journal, &rdev->flags)) {
  2716. if (rdev->mddev->pers == NULL) {
  2717. clear_bit(In_sync, &rdev->flags);
  2718. rdev->saved_raid_disk = rdev->raid_disk;
  2719. rdev->raid_disk = -1;
  2720. err = 0;
  2721. }
  2722. } else if (cmd_match(buf, "write_error")) {
  2723. set_bit(WriteErrorSeen, &rdev->flags);
  2724. err = 0;
  2725. } else if (cmd_match(buf, "-write_error")) {
  2726. clear_bit(WriteErrorSeen, &rdev->flags);
  2727. err = 0;
  2728. } else if (cmd_match(buf, "want_replacement")) {
  2729. /* Any non-spare device that is not a replacement can
  2730. * become want_replacement at any time, but we then need to
  2731. * check if recovery is needed.
  2732. */
  2733. if (rdev->raid_disk >= 0 &&
  2734. !test_bit(Journal, &rdev->flags) &&
  2735. !test_bit(Replacement, &rdev->flags))
  2736. set_bit(WantReplacement, &rdev->flags);
  2737. set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
  2738. md_wakeup_thread(rdev->mddev->thread);
  2739. err = 0;
  2740. } else if (cmd_match(buf, "-want_replacement")) {
  2741. /* Clearing 'want_replacement' is always allowed.
  2742. * Once replacements starts it is too late though.
  2743. */
  2744. err = 0;
  2745. clear_bit(WantReplacement, &rdev->flags);
  2746. } else if (cmd_match(buf, "replacement")) {
  2747. /* Can only set a device as a replacement when array has not
  2748. * yet been started. Once running, replacement is automatic
  2749. * from spares, or by assigning 'slot'.
  2750. */
  2751. if (rdev->mddev->pers)
  2752. err = -EBUSY;
  2753. else {
  2754. set_bit(Replacement, &rdev->flags);
  2755. err = 0;
  2756. }
  2757. } else if (cmd_match(buf, "-replacement")) {
  2758. /* Similarly, can only clear Replacement before start */
  2759. if (rdev->mddev->pers)
  2760. err = -EBUSY;
  2761. else {
  2762. clear_bit(Replacement, &rdev->flags);
  2763. err = 0;
  2764. }
  2765. } else if (cmd_match(buf, "re-add")) {
  2766. if (!rdev->mddev->pers)
  2767. err = -EINVAL;
  2768. else if (test_bit(Faulty, &rdev->flags) && (rdev->raid_disk == -1) &&
  2769. rdev->saved_raid_disk >= 0) {
  2770. /* clear_bit is performed _after_ all the devices
  2771. * have their local Faulty bit cleared. If any writes
  2772. * happen in the meantime in the local node, they
  2773. * will land in the local bitmap, which will be synced
  2774. * by this node eventually
  2775. */
  2776. if (!mddev_is_clustered(rdev->mddev) ||
  2777. (err = md_cluster_ops->gather_bitmaps(rdev)) == 0) {
  2778. clear_bit(Faulty, &rdev->flags);
  2779. err = add_bound_rdev(rdev);
  2780. }
  2781. } else
  2782. err = -EBUSY;
  2783. } else if (cmd_match(buf, "external_bbl") && (rdev->mddev->external)) {
  2784. set_bit(ExternalBbl, &rdev->flags);
  2785. rdev->badblocks.shift = 0;
  2786. err = 0;
  2787. } else if (cmd_match(buf, "-external_bbl") && (rdev->mddev->external)) {
  2788. clear_bit(ExternalBbl, &rdev->flags);
  2789. err = 0;
  2790. }
  2791. if (need_update_sb)
  2792. md_update_sb(mddev, 1);
  2793. if (!err)
  2794. sysfs_notify_dirent_safe(rdev->sysfs_state);
  2795. return err ? err : len;
  2796. }
  2797. static struct rdev_sysfs_entry rdev_state =
  2798. __ATTR_PREALLOC(state, S_IRUGO|S_IWUSR, state_show, state_store);
  2799. static ssize_t
  2800. errors_show(struct md_rdev *rdev, char *page)
  2801. {
  2802. return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors));
  2803. }
  2804. static ssize_t
  2805. errors_store(struct md_rdev *rdev, const char *buf, size_t len)
  2806. {
  2807. unsigned int n;
  2808. int rv;
  2809. rv = kstrtouint(buf, 10, &n);
  2810. if (rv < 0)
  2811. return rv;
  2812. atomic_set(&rdev->corrected_errors, n);
  2813. return len;
  2814. }
  2815. static struct rdev_sysfs_entry rdev_errors =
  2816. __ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
  2817. static ssize_t
  2818. slot_show(struct md_rdev *rdev, char *page)
  2819. {
  2820. if (test_bit(Journal, &rdev->flags))
  2821. return sprintf(page, "journal\n");
  2822. else if (rdev->raid_disk < 0)
  2823. return sprintf(page, "none\n");
  2824. else
  2825. return sprintf(page, "%d\n", rdev->raid_disk);
  2826. }
  2827. static ssize_t
  2828. slot_store(struct md_rdev *rdev, const char *buf, size_t len)
  2829. {
  2830. int slot;
  2831. int err;
  2832. if (test_bit(Journal, &rdev->flags))
  2833. return -EBUSY;
  2834. if (strncmp(buf, "none", 4)==0)
  2835. slot = -1;
  2836. else {
  2837. err = kstrtouint(buf, 10, (unsigned int *)&slot);
  2838. if (err < 0)
  2839. return err;
  2840. }
  2841. if (rdev->mddev->pers && slot == -1) {
  2842. /* Setting 'slot' on an active array requires also
  2843. * updating the 'rd%d' link, and communicating
  2844. * with the personality with ->hot_*_disk.
  2845. * For now we only support removing
  2846. * failed/spare devices. This normally happens automatically,
  2847. * but not when the metadata is externally managed.
  2848. */
  2849. if (rdev->raid_disk == -1)
  2850. return -EEXIST;
  2851. /* personality does all needed checks */
  2852. if (rdev->mddev->pers->hot_remove_disk == NULL)
  2853. return -EINVAL;
  2854. clear_bit(Blocked, &rdev->flags);
  2855. remove_and_add_spares(rdev->mddev, rdev);
  2856. if (rdev->raid_disk >= 0)
  2857. return -EBUSY;
  2858. set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
  2859. md_wakeup_thread(rdev->mddev->thread);
  2860. } else if (rdev->mddev->pers) {
  2861. /* Activating a spare .. or possibly reactivating
  2862. * if we ever get bitmaps working here.
  2863. */
  2864. int err;
  2865. if (rdev->raid_disk != -1)
  2866. return -EBUSY;
  2867. if (test_bit(MD_RECOVERY_RUNNING, &rdev->mddev->recovery))
  2868. return -EBUSY;
  2869. if (rdev->mddev->pers->hot_add_disk == NULL)
  2870. return -EINVAL;
  2871. if (slot >= rdev->mddev->raid_disks &&
  2872. slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
  2873. return -ENOSPC;
  2874. rdev->raid_disk = slot;
  2875. if (test_bit(In_sync, &rdev->flags))
  2876. rdev->saved_raid_disk = slot;
  2877. else
  2878. rdev->saved_raid_disk = -1;
  2879. clear_bit(In_sync, &rdev->flags);
  2880. clear_bit(Bitmap_sync, &rdev->flags);
  2881. err = rdev->mddev->pers->hot_add_disk(rdev->mddev, rdev);
  2882. if (err) {
  2883. rdev->raid_disk = -1;
  2884. return err;
  2885. } else
  2886. sysfs_notify_dirent_safe(rdev->sysfs_state);
  2887. /* failure here is OK */;
  2888. sysfs_link_rdev(rdev->mddev, rdev);
  2889. /* don't wakeup anyone, leave that to userspace. */
  2890. } else {
  2891. if (slot >= rdev->mddev->raid_disks &&
  2892. slot >= rdev->mddev->raid_disks + rdev->mddev->delta_disks)
  2893. return -ENOSPC;
  2894. rdev->raid_disk = slot;
  2895. /* assume it is working */
  2896. clear_bit(Faulty, &rdev->flags);
  2897. clear_bit(WriteMostly, &rdev->flags);
  2898. set_bit(In_sync, &rdev->flags);
  2899. sysfs_notify_dirent_safe(rdev->sysfs_state);
  2900. }
  2901. return len;
  2902. }
  2903. static struct rdev_sysfs_entry rdev_slot =
  2904. __ATTR(slot, S_IRUGO|S_IWUSR, slot_show, slot_store);
  2905. static ssize_t
  2906. offset_show(struct md_rdev *rdev, char *page)
  2907. {
  2908. return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
  2909. }
  2910. static ssize_t
  2911. offset_store(struct md_rdev *rdev, const char *buf, size_t len)
  2912. {
  2913. unsigned long long offset;
  2914. if (kstrtoull(buf, 10, &offset) < 0)
  2915. return -EINVAL;
  2916. if (rdev->mddev->pers && rdev->raid_disk >= 0)
  2917. return -EBUSY;
  2918. if (rdev->sectors && rdev->mddev->external)
  2919. /* Must set offset before size, so overlap checks
  2920. * can be sane */
  2921. return -EBUSY;
  2922. rdev->data_offset = offset;
  2923. rdev->new_data_offset = offset;
  2924. return len;
  2925. }
  2926. static struct rdev_sysfs_entry rdev_offset =
  2927. __ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store);
  2928. static ssize_t new_offset_show(struct md_rdev *rdev, char *page)
  2929. {
  2930. return sprintf(page, "%llu\n",
  2931. (unsigned long long)rdev->new_data_offset);
  2932. }
  2933. static ssize_t new_offset_store(struct md_rdev *rdev,
  2934. const char *buf, size_t len)
  2935. {
  2936. unsigned long long new_offset;
  2937. struct mddev *mddev = rdev->mddev;
  2938. if (kstrtoull(buf, 10, &new_offset) < 0)
  2939. return -EINVAL;
  2940. if (mddev->sync_thread ||
  2941. test_bit(MD_RECOVERY_RUNNING,&mddev->recovery))
  2942. return -EBUSY;
  2943. if (new_offset == rdev->data_offset)
  2944. /* reset is always permitted */
  2945. ;
  2946. else if (new_offset > rdev->data_offset) {
  2947. /* must not push array size beyond rdev_sectors */
  2948. if (new_offset - rdev->data_offset
  2949. + mddev->dev_sectors > rdev->sectors)
  2950. return -E2BIG;
  2951. }
  2952. /* Metadata worries about other space details. */
  2953. /* decreasing the offset is inconsistent with a backwards
  2954. * reshape.
  2955. */
  2956. if (new_offset < rdev->data_offset &&
  2957. mddev->reshape_backwards)
  2958. return -EINVAL;
  2959. /* Increasing offset is inconsistent with forwards
  2960. * reshape. reshape_direction should be set to
  2961. * 'backwards' first.
  2962. */
  2963. if (new_offset > rdev->data_offset &&
  2964. !mddev->reshape_backwards)
  2965. return -EINVAL;
  2966. if (mddev->pers && mddev->persistent &&
  2967. !super_types[mddev->major_version]
  2968. .allow_new_offset(rdev, new_offset))
  2969. return -E2BIG;
  2970. rdev->new_data_offset = new_offset;
  2971. if (new_offset > rdev->data_offset)
  2972. mddev->reshape_backwards = 1;
  2973. else if (new_offset < rdev->data_offset)
  2974. mddev->reshape_backwards = 0;
  2975. return len;
  2976. }
  2977. static struct rdev_sysfs_entry rdev_new_offset =
  2978. __ATTR(new_offset, S_IRUGO|S_IWUSR, new_offset_show, new_offset_store);
  2979. static ssize_t
  2980. rdev_size_show(struct md_rdev *rdev, char *page)
  2981. {
  2982. return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2);
  2983. }
  2984. static int overlaps(sector_t s1, sector_t l1, sector_t s2, sector_t l2)
  2985. {
  2986. /* check if two start/length pairs overlap */
  2987. if (s1+l1 <= s2)
  2988. return 0;
  2989. if (s2+l2 <= s1)
  2990. return 0;
  2991. return 1;
  2992. }
  2993. static int strict_blocks_to_sectors(const char *buf, sector_t *sectors)
  2994. {
  2995. unsigned long long blocks;
  2996. sector_t new;
  2997. if (kstrtoull(buf, 10, &blocks) < 0)
  2998. return -EINVAL;
  2999. if (blocks & 1ULL << (8 * sizeof(blocks) - 1))
  3000. return -EINVAL; /* sector conversion overflow */
  3001. new = blocks * 2;
  3002. if (new != blocks * 2)
  3003. return -EINVAL; /* unsigned long long to sector_t overflow */
  3004. *sectors = new;
  3005. return 0;
  3006. }
  3007. static ssize_t
  3008. rdev_size_store(struct md_rdev *rdev, const char *buf, size_t len)
  3009. {
  3010. struct mddev *my_mddev = rdev->mddev;
  3011. sector_t oldsectors = rdev->sectors;
  3012. sector_t sectors;
  3013. if (test_bit(Journal, &rdev->flags))
  3014. return -EBUSY;
  3015. if (strict_blocks_to_sectors(buf, &sectors) < 0)
  3016. return -EINVAL;
  3017. if (rdev->data_offset != rdev->new_data_offset)
  3018. return -EINVAL; /* too confusing */
  3019. if (my_mddev->pers && rdev->raid_disk >= 0) {
  3020. if (my_mddev->persistent) {
  3021. sectors = super_types[my_mddev->major_version].
  3022. rdev_size_change(rdev, sectors);
  3023. if (!sectors)
  3024. return -EBUSY;
  3025. } else if (!sectors)
  3026. sectors = (i_size_read(rdev->bdev->bd_inode) >> 9) -
  3027. rdev->data_offset;
  3028. if (!my_mddev->pers->resize)
  3029. /* Cannot change size for RAID0 or Linear etc */
  3030. return -EINVAL;
  3031. }
  3032. if (sectors < my_mddev->dev_sectors)
  3033. return -EINVAL; /* component must fit device */
  3034. rdev->sectors = sectors;
  3035. if (sectors > oldsectors && my_mddev->external) {
  3036. /* Need to check that all other rdevs with the same
  3037. * ->bdev do not overlap. 'rcu' is sufficient to walk
  3038. * the rdev lists safely.
  3039. * This check does not provide a hard guarantee, it
  3040. * just helps avoid dangerous mistakes.
  3041. */
  3042. struct mddev *mddev;
  3043. int overlap = 0;
  3044. struct list_head *tmp;
  3045. rcu_read_lock();
  3046. for_each_mddev(mddev, tmp) {
  3047. struct md_rdev *rdev2;
  3048. rdev_for_each(rdev2, mddev)
  3049. if (rdev->bdev == rdev2->bdev &&
  3050. rdev != rdev2 &&
  3051. overlaps(rdev->data_offset, rdev->sectors,
  3052. rdev2->data_offset,
  3053. rdev2->sectors)) {
  3054. overlap = 1;
  3055. break;
  3056. }
  3057. if (overlap) {
  3058. mddev_put(mddev);
  3059. break;
  3060. }
  3061. }
  3062. rcu_read_unlock();
  3063. if (overlap) {
  3064. /* Someone else could have slipped in a size
  3065. * change here, but doing so is just silly.
  3066. * We put oldsectors back because we *know* it is
  3067. * safe, and trust userspace not to race with
  3068. * itself
  3069. */
  3070. rdev->sectors = oldsectors;
  3071. return -EBUSY;
  3072. }
  3073. }
  3074. return len;
  3075. }
  3076. static struct rdev_sysfs_entry rdev_size =
  3077. __ATTR(size, S_IRUGO|S_IWUSR, rdev_size_show, rdev_size_store);
  3078. static ssize_t recovery_start_show(struct md_rdev *rdev, char *page)
  3079. {
  3080. unsigned long long recovery_start = rdev->recovery_offset;
  3081. if (test_bit(In_sync, &rdev->flags) ||
  3082. recovery_start == MaxSector)
  3083. return sprintf(page, "none\n");
  3084. return sprintf(page, "%llu\n", recovery_start);
  3085. }
  3086. static ssize_t recovery_start_store(struct md_rdev *rdev, const char *buf, size_t len)
  3087. {
  3088. unsigned long long recovery_start;
  3089. if (cmd_match(buf, "none"))
  3090. recovery_start = MaxSector;
  3091. else if (kstrtoull(buf, 10, &recovery_start))
  3092. return -EINVAL;
  3093. if (rdev->mddev->pers &&
  3094. rdev->raid_disk >= 0)
  3095. return -EBUSY;
  3096. rdev->recovery_offset = recovery_start;
  3097. if (recovery_start == MaxSector)
  3098. set_bit(In_sync, &rdev->flags);
  3099. else
  3100. clear_bit(In_sync, &rdev->flags);
  3101. return len;
  3102. }
  3103. static struct rdev_sysfs_entry rdev_recovery_start =
  3104. __ATTR(recovery_start, S_IRUGO|S_IWUSR, recovery_start_show, recovery_start_store);
  3105. /* sysfs access to bad-blocks list.
  3106. * We present two files.
  3107. * 'bad-blocks' lists sector numbers and lengths of ranges that
  3108. * are recorded as bad. The list is truncated to fit within
  3109. * the one-page limit of sysfs.
  3110. * Writing "sector length" to this file adds an acknowledged
  3111. * bad block list.
  3112. * 'unacknowledged-bad-blocks' lists bad blocks that have not yet
  3113. * been acknowledged. Writing to this file adds bad blocks
  3114. * without acknowledging them. This is largely for testing.
  3115. */
  3116. static ssize_t bb_show(struct md_rdev *rdev, char *page)
  3117. {
  3118. return badblocks_show(&rdev->badblocks, page, 0);
  3119. }
  3120. static ssize_t bb_store(struct md_rdev *rdev, const char *page, size_t len)
  3121. {
  3122. int rv = badblocks_store(&rdev->badblocks, page, len, 0);
  3123. /* Maybe that ack was all we needed */
  3124. if (test_and_clear_bit(BlockedBadBlocks, &rdev->flags))
  3125. wake_up(&rdev->blocked_wait);
  3126. return rv;
  3127. }
  3128. static struct rdev_sysfs_entry rdev_bad_blocks =
  3129. __ATTR(bad_blocks, S_IRUGO|S_IWUSR, bb_show, bb_store);
  3130. static ssize_t ubb_show(struct md_rdev *rdev, char *page)
  3131. {
  3132. return badblocks_show(&rdev->badblocks, page, 1);
  3133. }
  3134. static ssize_t ubb_store(struct md_rdev *rdev, const char *page, size_t len)
  3135. {
  3136. return badblocks_store(&rdev->badblocks, page, len, 1);
  3137. }
  3138. static struct rdev_sysfs_entry rdev_unack_bad_blocks =
  3139. __ATTR(unacknowledged_bad_blocks, S_IRUGO|S_IWUSR, ubb_show, ubb_store);
  3140. static ssize_t
  3141. ppl_sector_show(struct md_rdev *rdev, char *page)
  3142. {
  3143. return sprintf(page, "%llu\n", (unsigned long long)rdev->ppl.sector);
  3144. }
  3145. static ssize_t
  3146. ppl_sector_store(struct md_rdev *rdev, const char *buf, size_t len)
  3147. {
  3148. unsigned long long sector;
  3149. if (kstrtoull(buf, 10, &sector) < 0)
  3150. return -EINVAL;
  3151. if (sector != (sector_t)sector)
  3152. return -EINVAL;
  3153. if (rdev->mddev->pers && test_bit(MD_HAS_PPL, &rdev->mddev->flags) &&
  3154. rdev->raid_disk >= 0)
  3155. return -EBUSY;
  3156. if (rdev->mddev->persistent) {
  3157. if (rdev->mddev->major_version == 0)
  3158. return -EINVAL;
  3159. if ((sector > rdev->sb_start &&
  3160. sector - rdev->sb_start > S16_MAX) ||
  3161. (sector < rdev->sb_start &&
  3162. rdev->sb_start - sector > -S16_MIN))
  3163. return -EINVAL;
  3164. rdev->ppl.offset = sector - rdev->sb_start;
  3165. } else if (!rdev->mddev->external) {
  3166. return -EBUSY;
  3167. }
  3168. rdev->ppl.sector = sector;
  3169. return len;
  3170. }
  3171. static struct rdev_sysfs_entry rdev_ppl_sector =
  3172. __ATTR(ppl_sector, S_IRUGO|S_IWUSR, ppl_sector_show, ppl_sector_store);
  3173. static ssize_t
  3174. ppl_size_show(struct md_rdev *rdev, char *page)
  3175. {
  3176. return sprintf(page, "%u\n", rdev->ppl.size);
  3177. }
  3178. static ssize_t
  3179. ppl_size_store(struct md_rdev *rdev, const char *buf, size_t len)
  3180. {
  3181. unsigned int size;
  3182. if (kstrtouint(buf, 10, &size) < 0)
  3183. return -EINVAL;
  3184. if (rdev->mddev->pers && test_bit(MD_HAS_PPL, &rdev->mddev->flags) &&
  3185. rdev->raid_disk >= 0)
  3186. return -EBUSY;
  3187. if (rdev->mddev->persistent) {
  3188. if (rdev->mddev->major_version == 0)
  3189. return -EINVAL;
  3190. if (size > U16_MAX)
  3191. return -EINVAL;
  3192. } else if (!rdev->mddev->external) {
  3193. return -EBUSY;
  3194. }
  3195. rdev->ppl.size = size;
  3196. return len;
  3197. }
  3198. static struct rdev_sysfs_entry rdev_ppl_size =
  3199. __ATTR(ppl_size, S_IRUGO|S_IWUSR, ppl_size_show, ppl_size_store);
  3200. static struct attribute *rdev_default_attrs[] = {
  3201. &rdev_state.attr,
  3202. &rdev_errors.attr,
  3203. &rdev_slot.attr,
  3204. &rdev_offset.attr,
  3205. &rdev_new_offset.attr,
  3206. &rdev_size.attr,
  3207. &rdev_recovery_start.attr,
  3208. &rdev_bad_blocks.attr,
  3209. &rdev_unack_bad_blocks.attr,
  3210. &rdev_ppl_sector.attr,
  3211. &rdev_ppl_size.attr,
  3212. NULL,
  3213. };
  3214. static ssize_t
  3215. rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
  3216. {
  3217. struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
  3218. struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
  3219. if (!entry->show)
  3220. return -EIO;
  3221. if (!rdev->mddev)
  3222. return -ENODEV;
  3223. return entry->show(rdev, page);
  3224. }
  3225. static ssize_t
  3226. rdev_attr_store(struct kobject *kobj, struct attribute *attr,
  3227. const char *page, size_t length)
  3228. {
  3229. struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
  3230. struct md_rdev *rdev = container_of(kobj, struct md_rdev, kobj);
  3231. ssize_t rv;
  3232. struct mddev *mddev = rdev->mddev;
  3233. if (!entry->store)
  3234. return -EIO;
  3235. if (!capable(CAP_SYS_ADMIN))
  3236. return -EACCES;
  3237. rv = mddev ? mddev_lock(mddev) : -ENODEV;
  3238. if (!rv) {
  3239. if (rdev->mddev == NULL)
  3240. rv = -ENODEV;
  3241. else
  3242. rv = entry->store(rdev, page, length);
  3243. mddev_unlock(mddev);
  3244. }
  3245. return rv;
  3246. }
  3247. static void rdev_free(struct kobject *ko)
  3248. {
  3249. struct md_rdev *rdev = container_of(ko, struct md_rdev, kobj);
  3250. kfree(rdev);
  3251. }
  3252. static const struct sysfs_ops rdev_sysfs_ops = {
  3253. .show = rdev_attr_show,
  3254. .store = rdev_attr_store,
  3255. };
  3256. static struct kobj_type rdev_ktype = {
  3257. .release = rdev_free,
  3258. .sysfs_ops = &rdev_sysfs_ops,
  3259. .default_attrs = rdev_default_attrs,
  3260. };
  3261. int md_rdev_init(struct md_rdev *rdev)
  3262. {
  3263. rdev->desc_nr = -1;
  3264. rdev->saved_raid_disk = -1;
  3265. rdev->raid_disk = -1;
  3266. rdev->flags = 0;
  3267. rdev->data_offset = 0;
  3268. rdev->new_data_offset = 0;
  3269. rdev->sb_events = 0;
  3270. rdev->last_read_error = 0;
  3271. rdev->sb_loaded = 0;
  3272. rdev->bb_page = NULL;
  3273. atomic_set(&rdev->nr_pending, 0);
  3274. atomic_set(&rdev->read_errors, 0);
  3275. atomic_set(&rdev->corrected_errors, 0);
  3276. INIT_LIST_HEAD(&rdev->same_set);
  3277. init_waitqueue_head(&rdev->blocked_wait);
  3278. /* Add space to store bad block list.
  3279. * This reserves the space even on arrays where it cannot
  3280. * be used - I wonder if that matters
  3281. */
  3282. return badblocks_init(&rdev->badblocks, 0);
  3283. }
  3284. EXPORT_SYMBOL_GPL(md_rdev_init);
  3285. /*
  3286. * Import a device. If 'super_format' >= 0, then sanity check the superblock
  3287. *
  3288. * mark the device faulty if:
  3289. *
  3290. * - the device is nonexistent (zero size)
  3291. * - the device has no valid superblock
  3292. *
  3293. * a faulty rdev _never_ has rdev->sb set.
  3294. */
  3295. static struct md_rdev *md_import_device(dev_t newdev, int super_format, int super_minor)
  3296. {
  3297. char b[BDEVNAME_SIZE];
  3298. int err;
  3299. struct md_rdev *rdev;
  3300. sector_t size;
  3301. rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
  3302. if (!rdev)
  3303. return ERR_PTR(-ENOMEM);
  3304. err = md_rdev_init(rdev);
  3305. if (err)
  3306. goto abort_free;
  3307. err = alloc_disk_sb(rdev);
  3308. if (err)
  3309. goto abort_free;
  3310. err = lock_rdev(rdev, newdev, super_format == -2);
  3311. if (err)
  3312. goto abort_free;
  3313. kobject_init(&rdev->kobj, &rdev_ktype);
  3314. size = i_size_read(rdev->bdev->bd_inode) >> BLOCK_SIZE_BITS;
  3315. if (!size) {
  3316. pr_warn("md: %s has zero or unknown size, marking faulty!\n",
  3317. bdevname(rdev->bdev,b));
  3318. err = -EINVAL;
  3319. goto abort_free;
  3320. }
  3321. if (super_format >= 0) {
  3322. err = super_types[super_format].
  3323. load_super(rdev, NULL, super_minor);
  3324. if (err == -EINVAL) {
  3325. pr_warn("md: %s does not have a valid v%d.%d superblock, not importing!\n",
  3326. bdevname(rdev->bdev,b),
  3327. super_format, super_minor);
  3328. goto abort_free;
  3329. }
  3330. if (err < 0) {
  3331. pr_warn("md: could not read %s's sb, not importing!\n",
  3332. bdevname(rdev->bdev,b));
  3333. goto abort_free;
  3334. }
  3335. }
  3336. return rdev;
  3337. abort_free:
  3338. if (rdev->bdev)
  3339. unlock_rdev(rdev);
  3340. md_rdev_clear(rdev);
  3341. kfree(rdev);
  3342. return ERR_PTR(err);
  3343. }
  3344. /*
  3345. * Check a full RAID array for plausibility
  3346. */
  3347. static int analyze_sbs(struct mddev *mddev)
  3348. {
  3349. int i;
  3350. struct md_rdev *rdev, *freshest, *tmp;
  3351. char b[BDEVNAME_SIZE];
  3352. freshest = NULL;
  3353. rdev_for_each_safe(rdev, tmp, mddev)
  3354. switch (super_types[mddev->major_version].
  3355. load_super(rdev, freshest, mddev->minor_version)) {
  3356. case 1:
  3357. freshest = rdev;
  3358. break;
  3359. case 0:
  3360. break;
  3361. default:
  3362. pr_warn("md: fatal superblock inconsistency in %s -- removing from array\n",
  3363. bdevname(rdev->bdev,b));
  3364. md_kick_rdev_from_array(rdev);
  3365. }
  3366. /* Cannot find a valid fresh disk */
  3367. if (!freshest) {
  3368. pr_warn("md: cannot find a valid disk\n");
  3369. return -EINVAL;
  3370. }
  3371. super_types[mddev->major_version].
  3372. validate_super(mddev, freshest);
  3373. i = 0;
  3374. rdev_for_each_safe(rdev, tmp, mddev) {
  3375. if (mddev->max_disks &&
  3376. (rdev->desc_nr >= mddev->max_disks ||
  3377. i > mddev->max_disks)) {
  3378. pr_warn("md: %s: %s: only %d devices permitted\n",
  3379. mdname(mddev), bdevname(rdev->bdev, b),
  3380. mddev->max_disks);
  3381. md_kick_rdev_from_array(rdev);
  3382. continue;
  3383. }
  3384. if (rdev != freshest) {
  3385. if (super_types[mddev->major_version].
  3386. validate_super(mddev, rdev)) {
  3387. pr_warn("md: kicking non-fresh %s from array!\n",
  3388. bdevname(rdev->bdev,b));
  3389. md_kick_rdev_from_array(rdev);
  3390. continue;
  3391. }
  3392. }
  3393. if (mddev->level == LEVEL_MULTIPATH) {
  3394. rdev->desc_nr = i++;
  3395. rdev->raid_disk = rdev->desc_nr;
  3396. set_bit(In_sync, &rdev->flags);
  3397. } else if (rdev->raid_disk >=
  3398. (mddev->raid_disks - min(0, mddev->delta_disks)) &&
  3399. !test_bit(Journal, &rdev->flags)) {
  3400. rdev->raid_disk = -1;
  3401. clear_bit(In_sync, &rdev->flags);
  3402. }
  3403. }
  3404. return 0;
  3405. }
  3406. /* Read a fixed-point number.
  3407. * Numbers in sysfs attributes should be in "standard" units where
  3408. * possible, so time should be in seconds.
  3409. * However we internally use a a much smaller unit such as
  3410. * milliseconds or jiffies.
  3411. * This function takes a decimal number with a possible fractional
  3412. * component, and produces an integer which is the result of
  3413. * multiplying that number by 10^'scale'.
  3414. * all without any floating-point arithmetic.
  3415. */
  3416. int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale)
  3417. {
  3418. unsigned long result = 0;
  3419. long decimals = -1;
  3420. while (isdigit(*cp) || (*cp == '.' && decimals < 0)) {
  3421. if (*cp == '.')
  3422. decimals = 0;
  3423. else if (decimals < scale) {
  3424. unsigned int value;
  3425. value = *cp - '0';
  3426. result = result * 10 + value;
  3427. if (decimals >= 0)
  3428. decimals++;
  3429. }
  3430. cp++;
  3431. }
  3432. if (*cp == '\n')
  3433. cp++;
  3434. if (*cp)
  3435. return -EINVAL;
  3436. if (decimals < 0)
  3437. decimals = 0;
  3438. *res = result * int_pow(10, scale - decimals);
  3439. return 0;
  3440. }
  3441. static ssize_t
  3442. safe_delay_show(struct mddev *mddev, char *page)
  3443. {
  3444. int msec = (mddev->safemode_delay*1000)/HZ;
  3445. return sprintf(page, "%d.%03d\n", msec/1000, msec%1000);
  3446. }
  3447. static ssize_t
  3448. safe_delay_store(struct mddev *mddev, const char *cbuf, size_t len)
  3449. {
  3450. unsigned long msec;
  3451. if (mddev_is_clustered(mddev)) {
  3452. pr_warn("md: Safemode is disabled for clustered mode\n");
  3453. return -EINVAL;
  3454. }
  3455. if (strict_strtoul_scaled(cbuf, &msec, 3) < 0)
  3456. return -EINVAL;
  3457. if (msec == 0)
  3458. mddev->safemode_delay = 0;
  3459. else {
  3460. unsigned long old_delay = mddev->safemode_delay;
  3461. unsigned long new_delay = (msec*HZ)/1000;
  3462. if (new_delay == 0)
  3463. new_delay = 1;
  3464. mddev->safemode_delay = new_delay;
  3465. if (new_delay < old_delay || old_delay == 0)
  3466. mod_timer(&mddev->safemode_timer, jiffies+1);
  3467. }
  3468. return len;
  3469. }
  3470. static struct md_sysfs_entry md_safe_delay =
  3471. __ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store);
  3472. static ssize_t
  3473. level_show(struct mddev *mddev, char *page)
  3474. {
  3475. struct md_personality *p;
  3476. int ret;
  3477. spin_lock(&mddev->lock);
  3478. p = mddev->pers;
  3479. if (p)
  3480. ret = sprintf(page, "%s\n", p->name);
  3481. else if (mddev->clevel[0])
  3482. ret = sprintf(page, "%s\n", mddev->clevel);
  3483. else if (mddev->level != LEVEL_NONE)
  3484. ret = sprintf(page, "%d\n", mddev->level);
  3485. else
  3486. ret = 0;
  3487. spin_unlock(&mddev->lock);
  3488. return ret;
  3489. }
  3490. static ssize_t
  3491. level_store(struct mddev *mddev, const char *buf, size_t len)
  3492. {
  3493. char clevel[16];
  3494. ssize_t rv;
  3495. size_t slen = len;
  3496. struct md_personality *pers, *oldpers;
  3497. long level;
  3498. void *priv, *oldpriv;
  3499. struct md_rdev *rdev;
  3500. if (slen == 0 || slen >= sizeof(clevel))
  3501. return -EINVAL;
  3502. rv = mddev_lock(mddev);
  3503. if (rv)
  3504. return rv;
  3505. if (mddev->pers == NULL) {
  3506. strncpy(mddev->clevel, buf, slen);
  3507. if (mddev->clevel[slen-1] == '\n')
  3508. slen--;
  3509. mddev->clevel[slen] = 0;
  3510. mddev->level = LEVEL_NONE;
  3511. rv = len;
  3512. goto out_unlock;
  3513. }
  3514. rv = -EROFS;
  3515. if (mddev->ro)
  3516. goto out_unlock;
  3517. /* request to change the personality. Need to ensure:
  3518. * - array is not engaged in resync/recovery/reshape
  3519. * - old personality can be suspended
  3520. * - new personality will access other array.
  3521. */
  3522. rv = -EBUSY;
  3523. if (mddev->sync_thread ||
  3524. test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
  3525. mddev->reshape_position != MaxSector ||
  3526. mddev->sysfs_active)
  3527. goto out_unlock;
  3528. rv = -EINVAL;
  3529. if (!mddev->pers->quiesce) {
  3530. pr_warn("md: %s: %s does not support online personality change\n",
  3531. mdname(mddev), mddev->pers->name);
  3532. goto out_unlock;
  3533. }
  3534. /* Now find the new personality */
  3535. strncpy(clevel, buf, slen);
  3536. if (clevel[slen-1] == '\n')
  3537. slen--;
  3538. clevel[slen] = 0;
  3539. if (kstrtol(clevel, 10, &level))
  3540. level = LEVEL_NONE;
  3541. if (request_module("md-%s", clevel) != 0)
  3542. request_module("md-level-%s", clevel);
  3543. spin_lock(&pers_lock);
  3544. pers = find_pers(level, clevel);
  3545. if (!pers || !try_module_get(pers->owner)) {
  3546. spin_unlock(&pers_lock);
  3547. pr_warn("md: personality %s not loaded\n", clevel);
  3548. rv = -EINVAL;
  3549. goto out_unlock;
  3550. }
  3551. spin_unlock(&pers_lock);
  3552. if (pers == mddev->pers) {
  3553. /* Nothing to do! */
  3554. module_put(pers->owner);
  3555. rv = len;
  3556. goto out_unlock;
  3557. }
  3558. if (!pers->takeover) {
  3559. module_put(pers->owner);
  3560. pr_warn("md: %s: %s does not support personality takeover\n",
  3561. mdname(mddev), clevel);
  3562. rv = -EINVAL;
  3563. goto out_unlock;
  3564. }
  3565. rdev_for_each(rdev, mddev)
  3566. rdev->new_raid_disk = rdev->raid_disk;
  3567. /* ->takeover must set new_* and/or delta_disks
  3568. * if it succeeds, and may set them when it fails.
  3569. */
  3570. priv = pers->takeover(mddev);
  3571. if (IS_ERR(priv)) {
  3572. mddev->new_level = mddev->level;
  3573. mddev->new_layout = mddev->layout;
  3574. mddev->new_chunk_sectors = mddev->chunk_sectors;
  3575. mddev->raid_disks -= mddev->delta_disks;
  3576. mddev->delta_disks = 0;
  3577. mddev->reshape_backwards = 0;
  3578. module_put(pers->owner);
  3579. pr_warn("md: %s: %s would not accept array\n",
  3580. mdname(mddev), clevel);
  3581. rv = PTR_ERR(priv);
  3582. goto out_unlock;
  3583. }
  3584. /* Looks like we have a winner */
  3585. mddev_suspend(mddev);
  3586. mddev_detach(mddev);
  3587. spin_lock(&mddev->lock);
  3588. oldpers = mddev->pers;
  3589. oldpriv = mddev->private;
  3590. mddev->pers = pers;
  3591. mddev->private = priv;
  3592. strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
  3593. mddev->level = mddev->new_level;
  3594. mddev->layout = mddev->new_layout;
  3595. mddev->chunk_sectors = mddev->new_chunk_sectors;
  3596. mddev->delta_disks = 0;
  3597. mddev->reshape_backwards = 0;
  3598. mddev->degraded = 0;
  3599. spin_unlock(&mddev->lock);
  3600. if (oldpers->sync_request == NULL &&
  3601. mddev->external) {
  3602. /* We are converting from a no-redundancy array
  3603. * to a redundancy array and metadata is managed
  3604. * externally so we need to be sure that writes
  3605. * won't block due to a need to transition
  3606. * clean->dirty
  3607. * until external management is started.
  3608. */
  3609. mddev->in_sync = 0;
  3610. mddev->safemode_delay = 0;
  3611. mddev->safemode = 0;
  3612. }
  3613. oldpers->free(mddev, oldpriv);
  3614. if (oldpers->sync_request == NULL &&
  3615. pers->sync_request != NULL) {
  3616. /* need to add the md_redundancy_group */
  3617. if (sysfs_create_group(&mddev->kobj, &md_redundancy_group))
  3618. pr_warn("md: cannot register extra attributes for %s\n",
  3619. mdname(mddev));
  3620. mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, "sync_action");
  3621. mddev->sysfs_completed = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_completed");
  3622. mddev->sysfs_degraded = sysfs_get_dirent_safe(mddev->kobj.sd, "degraded");
  3623. }
  3624. if (oldpers->sync_request != NULL &&
  3625. pers->sync_request == NULL) {
  3626. /* need to remove the md_redundancy_group */
  3627. if (mddev->to_remove == NULL)
  3628. mddev->to_remove = &md_redundancy_group;
  3629. }
  3630. module_put(oldpers->owner);
  3631. rdev_for_each(rdev, mddev) {
  3632. if (rdev->raid_disk < 0)
  3633. continue;
  3634. if (rdev->new_raid_disk >= mddev->raid_disks)
  3635. rdev->new_raid_disk = -1;
  3636. if (rdev->new_raid_disk == rdev->raid_disk)
  3637. continue;
  3638. sysfs_unlink_rdev(mddev, rdev);
  3639. }
  3640. rdev_for_each(rdev, mddev) {
  3641. if (rdev->raid_disk < 0)
  3642. continue;
  3643. if (rdev->new_raid_disk == rdev->raid_disk)
  3644. continue;
  3645. rdev->raid_disk = rdev->new_raid_disk;
  3646. if (rdev->raid_disk < 0)
  3647. clear_bit(In_sync, &rdev->flags);
  3648. else {
  3649. if (sysfs_link_rdev(mddev, rdev))
  3650. pr_warn("md: cannot register rd%d for %s after level change\n",
  3651. rdev->raid_disk, mdname(mddev));
  3652. }
  3653. }
  3654. if (pers->sync_request == NULL) {
  3655. /* this is now an array without redundancy, so
  3656. * it must always be in_sync
  3657. */
  3658. mddev->in_sync = 1;
  3659. del_timer_sync(&mddev->safemode_timer);
  3660. }
  3661. blk_set_stacking_limits(&mddev->queue->limits);
  3662. pers->run(mddev);
  3663. set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
  3664. mddev_resume(mddev);
  3665. if (!mddev->thread)
  3666. md_update_sb(mddev, 1);
  3667. sysfs_notify_dirent_safe(mddev->sysfs_level);
  3668. md_new_event(mddev);
  3669. rv = len;
  3670. out_unlock:
  3671. mddev_unlock(mddev);
  3672. return rv;
  3673. }
  3674. static struct md_sysfs_entry md_level =
  3675. __ATTR(level, S_IRUGO|S_IWUSR, level_show, level_store);
  3676. static ssize_t
  3677. layout_show(struct mddev *mddev, char *page)
  3678. {
  3679. /* just a number, not meaningful for all levels */
  3680. if (mddev->reshape_position != MaxSector &&
  3681. mddev->layout != mddev->new_layout)
  3682. return sprintf(page, "%d (%d)\n",
  3683. mddev->new_layout, mddev->layout);
  3684. return sprintf(page, "%d\n", mddev->layout);
  3685. }
  3686. static ssize_t
  3687. layout_store(struct mddev *mddev, const char *buf, size_t len)
  3688. {
  3689. unsigned int n;
  3690. int err;
  3691. err = kstrtouint(buf, 10, &n);
  3692. if (err < 0)
  3693. return err;
  3694. err = mddev_lock(mddev);
  3695. if (err)
  3696. return err;
  3697. if (mddev->pers) {
  3698. if (mddev->pers->check_reshape == NULL)
  3699. err = -EBUSY;
  3700. else if (mddev->ro)
  3701. err = -EROFS;
  3702. else {
  3703. mddev->new_layout = n;
  3704. err = mddev->pers->check_reshape(mddev);
  3705. if (err)
  3706. mddev->new_layout = mddev->layout;
  3707. }
  3708. } else {
  3709. mddev->new_layout = n;
  3710. if (mddev->reshape_position == MaxSector)
  3711. mddev->layout = n;
  3712. }
  3713. mddev_unlock(mddev);
  3714. return err ?: len;
  3715. }
  3716. static struct md_sysfs_entry md_layout =
  3717. __ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store);
  3718. static ssize_t
  3719. raid_disks_show(struct mddev *mddev, char *page)
  3720. {
  3721. if (mddev->raid_disks == 0)
  3722. return 0;
  3723. if (mddev->reshape_position != MaxSector &&
  3724. mddev->delta_disks != 0)
  3725. return sprintf(page, "%d (%d)\n", mddev->raid_disks,
  3726. mddev->raid_disks - mddev->delta_disks);
  3727. return sprintf(page, "%d\n", mddev->raid_disks);
  3728. }
  3729. static int update_raid_disks(struct mddev *mddev, int raid_disks);
  3730. static ssize_t
  3731. raid_disks_store(struct mddev *mddev, const char *buf, size_t len)
  3732. {
  3733. unsigned int n;
  3734. int err;
  3735. err = kstrtouint(buf, 10, &n);
  3736. if (err < 0)
  3737. return err;
  3738. err = mddev_lock(mddev);
  3739. if (err)
  3740. return err;
  3741. if (mddev->pers)
  3742. err = update_raid_disks(mddev, n);
  3743. else if (mddev->reshape_position != MaxSector) {
  3744. struct md_rdev *rdev;
  3745. int olddisks = mddev->raid_disks - mddev->delta_disks;
  3746. err = -EINVAL;
  3747. rdev_for_each(rdev, mddev) {
  3748. if (olddisks < n &&
  3749. rdev->data_offset < rdev->new_data_offset)
  3750. goto out_unlock;
  3751. if (olddisks > n &&
  3752. rdev->data_offset > rdev->new_data_offset)
  3753. goto out_unlock;
  3754. }
  3755. err = 0;
  3756. mddev->delta_disks = n - olddisks;
  3757. mddev->raid_disks = n;
  3758. mddev->reshape_backwards = (mddev->delta_disks < 0);
  3759. } else
  3760. mddev->raid_disks = n;
  3761. out_unlock:
  3762. mddev_unlock(mddev);
  3763. return err ? err : len;
  3764. }
  3765. static struct md_sysfs_entry md_raid_disks =
  3766. __ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
  3767. static ssize_t
  3768. uuid_show(struct mddev *mddev, char *page)
  3769. {
  3770. return sprintf(page, "%pU\n", mddev->uuid);
  3771. }
  3772. static struct md_sysfs_entry md_uuid =
  3773. __ATTR(uuid, S_IRUGO, uuid_show, NULL);
  3774. static ssize_t
  3775. chunk_size_show(struct mddev *mddev, char *page)
  3776. {
  3777. if (mddev->reshape_position != MaxSector &&
  3778. mddev->chunk_sectors != mddev->new_chunk_sectors)
  3779. return sprintf(page, "%d (%d)\n",
  3780. mddev->new_chunk_sectors << 9,
  3781. mddev->chunk_sectors << 9);
  3782. return sprintf(page, "%d\n", mddev->chunk_sectors << 9);
  3783. }
  3784. static ssize_t
  3785. chunk_size_store(struct mddev *mddev, const char *buf, size_t len)
  3786. {
  3787. unsigned long n;
  3788. int err;
  3789. err = kstrtoul(buf, 10, &n);
  3790. if (err < 0)
  3791. return err;
  3792. err = mddev_lock(mddev);
  3793. if (err)
  3794. return err;
  3795. if (mddev->pers) {
  3796. if (mddev->pers->check_reshape == NULL)
  3797. err = -EBUSY;
  3798. else if (mddev->ro)
  3799. err = -EROFS;
  3800. else {
  3801. mddev->new_chunk_sectors = n >> 9;
  3802. err = mddev->pers->check_reshape(mddev);
  3803. if (err)
  3804. mddev->new_chunk_sectors = mddev->chunk_sectors;
  3805. }
  3806. } else {
  3807. mddev->new_chunk_sectors = n >> 9;
  3808. if (mddev->reshape_position == MaxSector)
  3809. mddev->chunk_sectors = n >> 9;
  3810. }
  3811. mddev_unlock(mddev);
  3812. return err ?: len;
  3813. }
  3814. static struct md_sysfs_entry md_chunk_size =
  3815. __ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
  3816. static ssize_t
  3817. resync_start_show(struct mddev *mddev, char *page)
  3818. {
  3819. if (mddev->recovery_cp == MaxSector)
  3820. return sprintf(page, "none\n");
  3821. return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp);
  3822. }
  3823. static ssize_t
  3824. resync_start_store(struct mddev *mddev, const char *buf, size_t len)
  3825. {
  3826. unsigned long long n;
  3827. int err;
  3828. if (cmd_match(buf, "none"))
  3829. n = MaxSector;
  3830. else {
  3831. err = kstrtoull(buf, 10, &n);
  3832. if (err < 0)
  3833. return err;
  3834. if (n != (sector_t)n)
  3835. return -EINVAL;
  3836. }
  3837. err = mddev_lock(mddev);
  3838. if (err)
  3839. return err;
  3840. if (mddev->pers && !test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
  3841. err = -EBUSY;
  3842. if (!err) {
  3843. mddev->recovery_cp = n;
  3844. if (mddev->pers)
  3845. set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
  3846. }
  3847. mddev_unlock(mddev);
  3848. return err ?: len;
  3849. }
  3850. static struct md_sysfs_entry md_resync_start =
  3851. __ATTR_PREALLOC(resync_start, S_IRUGO|S_IWUSR,
  3852. resync_start_show, resync_start_store);
  3853. /*
  3854. * The array state can be:
  3855. *
  3856. * clear
  3857. * No devices, no size, no level
  3858. * Equivalent to STOP_ARRAY ioctl
  3859. * inactive
  3860. * May have some settings, but array is not active
  3861. * all IO results in error
  3862. * When written, doesn't tear down array, but just stops it
  3863. * suspended (not supported yet)
  3864. * All IO requests will block. The array can be reconfigured.
  3865. * Writing this, if accepted, will block until array is quiescent
  3866. * readonly
  3867. * no resync can happen. no superblocks get written.
  3868. * write requests fail
  3869. * read-auto
  3870. * like readonly, but behaves like 'clean' on a write request.
  3871. *
  3872. * clean - no pending writes, but otherwise active.
  3873. * When written to inactive array, starts without resync
  3874. * If a write request arrives then
  3875. * if metadata is known, mark 'dirty' and switch to 'active'.
  3876. * if not known, block and switch to write-pending
  3877. * If written to an active array that has pending writes, then fails.
  3878. * active
  3879. * fully active: IO and resync can be happening.
  3880. * When written to inactive array, starts with resync
  3881. *
  3882. * write-pending
  3883. * clean, but writes are blocked waiting for 'active' to be written.
  3884. *
  3885. * active-idle
  3886. * like active, but no writes have been seen for a while (100msec).
  3887. *
  3888. * broken
  3889. * RAID0/LINEAR-only: same as clean, but array is missing a member.
  3890. * It's useful because RAID0/LINEAR mounted-arrays aren't stopped
  3891. * when a member is gone, so this state will at least alert the
  3892. * user that something is wrong.
  3893. */
  3894. enum array_state { clear, inactive, suspended, readonly, read_auto, clean, active,
  3895. write_pending, active_idle, broken, bad_word};
  3896. static char *array_states[] = {
  3897. "clear", "inactive", "suspended", "readonly", "read-auto", "clean", "active",
  3898. "write-pending", "active-idle", "broken", NULL };
  3899. static int match_word(const char *word, char **list)
  3900. {
  3901. int n;
  3902. for (n=0; list[n]; n++)
  3903. if (cmd_match(word, list[n]))
  3904. break;
  3905. return n;
  3906. }
  3907. static ssize_t
  3908. array_state_show(struct mddev *mddev, char *page)
  3909. {
  3910. enum array_state st = inactive;
  3911. if (mddev->pers && !test_bit(MD_NOT_READY, &mddev->flags)) {
  3912. switch(mddev->ro) {
  3913. case 1:
  3914. st = readonly;
  3915. break;
  3916. case 2:
  3917. st = read_auto;
  3918. break;
  3919. case 0:
  3920. spin_lock(&mddev->lock);
  3921. if (test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags))
  3922. st = write_pending;
  3923. else if (mddev->in_sync)
  3924. st = clean;
  3925. else if (mddev->safemode)
  3926. st = active_idle;
  3927. else
  3928. st = active;
  3929. spin_unlock(&mddev->lock);
  3930. }
  3931. if (test_bit(MD_BROKEN, &mddev->flags) && st == clean)
  3932. st = broken;
  3933. } else {
  3934. if (list_empty(&mddev->disks) &&
  3935. mddev->raid_disks == 0 &&
  3936. mddev->dev_sectors == 0)
  3937. st = clear;
  3938. else
  3939. st = inactive;
  3940. }
  3941. return sprintf(page, "%s\n", array_states[st]);
  3942. }
  3943. static int do_md_stop(struct mddev *mddev, int ro, struct block_device *bdev);
  3944. static int md_set_readonly(struct mddev *mddev, struct block_device *bdev);
  3945. static int restart_array(struct mddev *mddev);
  3946. static ssize_t
  3947. array_state_store(struct mddev *mddev, const char *buf, size_t len)
  3948. {
  3949. int err = 0;
  3950. enum array_state st = match_word(buf, array_states);
  3951. if (mddev->pers && (st == active || st == clean) && mddev->ro != 1) {
  3952. /* don't take reconfig_mutex when toggling between
  3953. * clean and active
  3954. */
  3955. spin_lock(&mddev->lock);
  3956. if (st == active) {
  3957. restart_array(mddev);
  3958. clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
  3959. md_wakeup_thread(mddev->thread);
  3960. wake_up(&mddev->sb_wait);
  3961. } else /* st == clean */ {
  3962. restart_array(mddev);
  3963. if (!set_in_sync(mddev))
  3964. err = -EBUSY;
  3965. }
  3966. if (!err)
  3967. sysfs_notify_dirent_safe(mddev->sysfs_state);
  3968. spin_unlock(&mddev->lock);
  3969. return err ?: len;
  3970. }
  3971. err = mddev_lock(mddev);
  3972. if (err)
  3973. return err;
  3974. err = -EINVAL;
  3975. switch(st) {
  3976. case bad_word:
  3977. break;
  3978. case clear:
  3979. /* stopping an active array */
  3980. err = do_md_stop(mddev, 0, NULL);
  3981. break;
  3982. case inactive:
  3983. /* stopping an active array */
  3984. if (mddev->pers)
  3985. err = do_md_stop(mddev, 2, NULL);
  3986. else
  3987. err = 0; /* already inactive */
  3988. break;
  3989. case suspended:
  3990. break; /* not supported yet */
  3991. case readonly:
  3992. if (mddev->pers)
  3993. err = md_set_readonly(mddev, NULL);
  3994. else {
  3995. mddev->ro = 1;
  3996. set_disk_ro(mddev->gendisk, 1);
  3997. err = do_md_run(mddev);
  3998. }
  3999. break;
  4000. case read_auto:
  4001. if (mddev->pers) {
  4002. if (mddev->ro == 0)
  4003. err = md_set_readonly(mddev, NULL);
  4004. else if (mddev->ro == 1)
  4005. err = restart_array(mddev);
  4006. if (err == 0) {
  4007. mddev->ro = 2;
  4008. set_disk_ro(mddev->gendisk, 0);
  4009. }
  4010. } else {
  4011. mddev->ro = 2;
  4012. err = do_md_run(mddev);
  4013. }
  4014. break;
  4015. case clean:
  4016. if (mddev->pers) {
  4017. err = restart_array(mddev);
  4018. if (err)
  4019. break;
  4020. spin_lock(&mddev->lock);
  4021. if (!set_in_sync(mddev))
  4022. err = -EBUSY;
  4023. spin_unlock(&mddev->lock);
  4024. } else
  4025. err = -EINVAL;
  4026. break;
  4027. case active:
  4028. if (mddev->pers) {
  4029. err = restart_array(mddev);
  4030. if (err)
  4031. break;
  4032. clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
  4033. wake_up(&mddev->sb_wait);
  4034. err = 0;
  4035. } else {
  4036. mddev->ro = 0;
  4037. set_disk_ro(mddev->gendisk, 0);
  4038. err = do_md_run(mddev);
  4039. }
  4040. break;
  4041. case write_pending:
  4042. case active_idle:
  4043. case broken:
  4044. /* these cannot be set */
  4045. break;
  4046. }
  4047. if (!err) {
  4048. if (mddev->hold_active == UNTIL_IOCTL)
  4049. mddev->hold_active = 0;
  4050. sysfs_notify_dirent_safe(mddev->sysfs_state);
  4051. }
  4052. mddev_unlock(mddev);
  4053. return err ?: len;
  4054. }
  4055. static struct md_sysfs_entry md_array_state =
  4056. __ATTR_PREALLOC(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
  4057. static ssize_t
  4058. max_corrected_read_errors_show(struct mddev *mddev, char *page) {
  4059. return sprintf(page, "%d\n",
  4060. atomic_read(&mddev->max_corr_read_errors));
  4061. }
  4062. static ssize_t
  4063. max_corrected_read_errors_store(struct mddev *mddev, const char *buf, size_t len)
  4064. {
  4065. unsigned int n;
  4066. int rv;
  4067. rv = kstrtouint(buf, 10, &n);
  4068. if (rv < 0)
  4069. return rv;
  4070. atomic_set(&mddev->max_corr_read_errors, n);
  4071. return len;
  4072. }
  4073. static struct md_sysfs_entry max_corr_read_errors =
  4074. __ATTR(max_read_errors, S_IRUGO|S_IWUSR, max_corrected_read_errors_show,
  4075. max_corrected_read_errors_store);
  4076. static ssize_t
  4077. null_show(struct mddev *mddev, char *page)
  4078. {
  4079. return -EINVAL;
  4080. }
  4081. /* need to ensure rdev_delayed_delete() has completed */
  4082. static void flush_rdev_wq(struct mddev *mddev)
  4083. {
  4084. struct md_rdev *rdev;
  4085. rcu_read_lock();
  4086. rdev_for_each_rcu(rdev, mddev)
  4087. if (work_pending(&rdev->del_work)) {
  4088. flush_workqueue(md_rdev_misc_wq);
  4089. break;
  4090. }
  4091. rcu_read_unlock();
  4092. }
  4093. static ssize_t
  4094. new_dev_store(struct mddev *mddev, const char *buf, size_t len)
  4095. {
  4096. /* buf must be %d:%d\n? giving major and minor numbers */
  4097. /* The new device is added to the array.
  4098. * If the array has a persistent superblock, we read the
  4099. * superblock to initialise info and check validity.
  4100. * Otherwise, only checking done is that in bind_rdev_to_array,
  4101. * which mainly checks size.
  4102. */
  4103. char *e;
  4104. int major = simple_strtoul(buf, &e, 10);
  4105. int minor;
  4106. dev_t dev;
  4107. struct md_rdev *rdev;
  4108. int err;
  4109. if (!*buf || *e != ':' || !e[1] || e[1] == '\n')
  4110. return -EINVAL;
  4111. minor = simple_strtoul(e+1, &e, 10);
  4112. if (*e && *e != '\n')
  4113. return -EINVAL;
  4114. dev = MKDEV(major, minor);
  4115. if (major != MAJOR(dev) ||
  4116. minor != MINOR(dev))
  4117. return -EOVERFLOW;
  4118. flush_rdev_wq(mddev);
  4119. err = mddev_lock(mddev);
  4120. if (err)
  4121. return err;
  4122. if (mddev->persistent) {
  4123. rdev = md_import_device(dev, mddev->major_version,
  4124. mddev->minor_version);
  4125. if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
  4126. struct md_rdev *rdev0
  4127. = list_entry(mddev->disks.next,
  4128. struct md_rdev, same_set);
  4129. err = super_types[mddev->major_version]
  4130. .load_super(rdev, rdev0, mddev->minor_version);
  4131. if (err < 0)
  4132. goto out;
  4133. }
  4134. } else if (mddev->external)
  4135. rdev = md_import_device(dev, -2, -1);
  4136. else
  4137. rdev = md_import_device(dev, -1, -1);
  4138. if (IS_ERR(rdev)) {
  4139. mddev_unlock(mddev);
  4140. return PTR_ERR(rdev);
  4141. }
  4142. err = bind_rdev_to_array(rdev, mddev);
  4143. out:
  4144. if (err)
  4145. export_rdev(rdev);
  4146. mddev_unlock(mddev);
  4147. if (!err)
  4148. md_new_event(mddev);
  4149. return err ? err : len;
  4150. }
  4151. static struct md_sysfs_entry md_new_device =
  4152. __ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
  4153. static ssize_t
  4154. bitmap_store(struct mddev *mddev, const char *buf, size_t len)
  4155. {
  4156. char *end;
  4157. unsigned long chunk, end_chunk;
  4158. int err;
  4159. err = mddev_lock(mddev);
  4160. if (err)
  4161. return err;
  4162. if (!mddev->bitmap)
  4163. goto out;
  4164. /* buf should be <chunk> <chunk> ... or <chunk>-<chunk> ... (range) */
  4165. while (*buf) {
  4166. chunk = end_chunk = simple_strtoul(buf, &end, 0);
  4167. if (buf == end) break;
  4168. if (*end == '-') { /* range */
  4169. buf = end + 1;
  4170. end_chunk = simple_strtoul(buf, &end, 0);
  4171. if (buf == end) break;
  4172. }
  4173. if (*end && !isspace(*end)) break;
  4174. md_bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk);
  4175. buf = skip_spaces(end);
  4176. }
  4177. md_bitmap_unplug(mddev->bitmap); /* flush the bits to disk */
  4178. out:
  4179. mddev_unlock(mddev);
  4180. return len;
  4181. }
  4182. static struct md_sysfs_entry md_bitmap =
  4183. __ATTR(bitmap_set_bits, S_IWUSR, null_show, bitmap_store);
  4184. static ssize_t
  4185. size_show(struct mddev *mddev, char *page)
  4186. {
  4187. return sprintf(page, "%llu\n",
  4188. (unsigned long long)mddev->dev_sectors / 2);
  4189. }
  4190. static int update_size(struct mddev *mddev, sector_t num_sectors);
  4191. static ssize_t
  4192. size_store(struct mddev *mddev, const char *buf, size_t len)
  4193. {
  4194. /* If array is inactive, we can reduce the component size, but
  4195. * not increase it (except from 0).
  4196. * If array is active, we can try an on-line resize
  4197. */
  4198. sector_t sectors;
  4199. int err = strict_blocks_to_sectors(buf, &sectors);
  4200. if (err < 0)
  4201. return err;
  4202. err = mddev_lock(mddev);
  4203. if (err)
  4204. return err;
  4205. if (mddev->pers) {
  4206. err = update_size(mddev, sectors);
  4207. if (err == 0)
  4208. md_update_sb(mddev, 1);
  4209. } else {
  4210. if (mddev->dev_sectors == 0 ||
  4211. mddev->dev_sectors > sectors)
  4212. mddev->dev_sectors = sectors;
  4213. else
  4214. err = -ENOSPC;
  4215. }
  4216. mddev_unlock(mddev);
  4217. return err ? err : len;
  4218. }
  4219. static struct md_sysfs_entry md_size =
  4220. __ATTR(component_size, S_IRUGO|S_IWUSR, size_show, size_store);
  4221. /* Metadata version.
  4222. * This is one of
  4223. * 'none' for arrays with no metadata (good luck...)
  4224. * 'external' for arrays with externally managed metadata,
  4225. * or N.M for internally known formats
  4226. */
  4227. static ssize_t
  4228. metadata_show(struct mddev *mddev, char *page)
  4229. {
  4230. if (mddev->persistent)
  4231. return sprintf(page, "%d.%d\n",
  4232. mddev->major_version, mddev->minor_version);
  4233. else if (mddev->external)
  4234. return sprintf(page, "external:%s\n", mddev->metadata_type);
  4235. else
  4236. return sprintf(page, "none\n");
  4237. }
  4238. static ssize_t
  4239. metadata_store(struct mddev *mddev, const char *buf, size_t len)
  4240. {
  4241. int major, minor;
  4242. char *e;
  4243. int err;
  4244. /* Changing the details of 'external' metadata is
  4245. * always permitted. Otherwise there must be
  4246. * no devices attached to the array.
  4247. */
  4248. err = mddev_lock(mddev);
  4249. if (err)
  4250. return err;
  4251. err = -EBUSY;
  4252. if (mddev->external && strncmp(buf, "external:", 9) == 0)
  4253. ;
  4254. else if (!list_empty(&mddev->disks))
  4255. goto out_unlock;
  4256. err = 0;
  4257. if (cmd_match(buf, "none")) {
  4258. mddev->persistent = 0;
  4259. mddev->external = 0;
  4260. mddev->major_version = 0;
  4261. mddev->minor_version = 90;
  4262. goto out_unlock;
  4263. }
  4264. if (strncmp(buf, "external:", 9) == 0) {
  4265. size_t namelen = len-9;
  4266. if (namelen >= sizeof(mddev->metadata_type))
  4267. namelen = sizeof(mddev->metadata_type)-1;
  4268. strncpy(mddev->metadata_type, buf+9, namelen);
  4269. mddev->metadata_type[namelen] = 0;
  4270. if (namelen && mddev->metadata_type[namelen-1] == '\n')
  4271. mddev->metadata_type[--namelen] = 0;
  4272. mddev->persistent = 0;
  4273. mddev->external = 1;
  4274. mddev->major_version = 0;
  4275. mddev->minor_version = 90;
  4276. goto out_unlock;
  4277. }
  4278. major = simple_strtoul(buf, &e, 10);
  4279. err = -EINVAL;
  4280. if (e==buf || *e != '.')
  4281. goto out_unlock;
  4282. buf = e+1;
  4283. minor = simple_strtoul(buf, &e, 10);
  4284. if (e==buf || (*e && *e != '\n') )
  4285. goto out_unlock;
  4286. err = -ENOENT;
  4287. if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL)
  4288. goto out_unlock;
  4289. mddev->major_version = major;
  4290. mddev->minor_version = minor;
  4291. mddev->persistent = 1;
  4292. mddev->external = 0;
  4293. err = 0;
  4294. out_unlock:
  4295. mddev_unlock(mddev);
  4296. return err ?: len;
  4297. }
  4298. static struct md_sysfs_entry md_metadata =
  4299. __ATTR_PREALLOC(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
  4300. static ssize_t
  4301. action_show(struct mddev *mddev, char *page)
  4302. {
  4303. char *type = "idle";
  4304. unsigned long recovery = mddev->recovery;
  4305. if (test_bit(MD_RECOVERY_FROZEN, &recovery))
  4306. type = "frozen";
  4307. else if (test_bit(MD_RECOVERY_RUNNING, &recovery) ||
  4308. (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &recovery))) {
  4309. if (test_bit(MD_RECOVERY_RESHAPE, &recovery))
  4310. type = "reshape";
  4311. else if (test_bit(MD_RECOVERY_SYNC, &recovery)) {
  4312. if (!test_bit(MD_RECOVERY_REQUESTED, &recovery))
  4313. type = "resync";
  4314. else if (test_bit(MD_RECOVERY_CHECK, &recovery))
  4315. type = "check";
  4316. else
  4317. type = "repair";
  4318. } else if (test_bit(MD_RECOVERY_RECOVER, &recovery))
  4319. type = "recover";
  4320. else if (mddev->reshape_position != MaxSector)
  4321. type = "reshape";
  4322. }
  4323. return sprintf(page, "%s\n", type);
  4324. }
  4325. static ssize_t
  4326. action_store(struct mddev *mddev, const char *page, size_t len)
  4327. {
  4328. if (!mddev->pers || !mddev->pers->sync_request)
  4329. return -EINVAL;
  4330. if (cmd_match(page, "idle") || cmd_match(page, "frozen")) {
  4331. if (cmd_match(page, "frozen"))
  4332. set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
  4333. else
  4334. clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
  4335. if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
  4336. mddev_lock(mddev) == 0) {
  4337. if (work_pending(&mddev->del_work))
  4338. flush_workqueue(md_misc_wq);
  4339. if (mddev->sync_thread) {
  4340. set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  4341. md_reap_sync_thread(mddev);
  4342. }
  4343. mddev_unlock(mddev);
  4344. }
  4345. } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
  4346. return -EBUSY;
  4347. else if (cmd_match(page, "resync"))
  4348. clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
  4349. else if (cmd_match(page, "recover")) {
  4350. clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
  4351. set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
  4352. } else if (cmd_match(page, "reshape")) {
  4353. int err;
  4354. if (mddev->pers->start_reshape == NULL)
  4355. return -EINVAL;
  4356. err = mddev_lock(mddev);
  4357. if (!err) {
  4358. if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
  4359. err = -EBUSY;
  4360. else {
  4361. clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
  4362. err = mddev->pers->start_reshape(mddev);
  4363. }
  4364. mddev_unlock(mddev);
  4365. }
  4366. if (err)
  4367. return err;
  4368. sysfs_notify_dirent_safe(mddev->sysfs_degraded);
  4369. } else {
  4370. if (cmd_match(page, "check"))
  4371. set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
  4372. else if (!cmd_match(page, "repair"))
  4373. return -EINVAL;
  4374. clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
  4375. set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
  4376. set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
  4377. }
  4378. if (mddev->ro == 2) {
  4379. /* A write to sync_action is enough to justify
  4380. * canceling read-auto mode
  4381. */
  4382. mddev->ro = 0;
  4383. md_wakeup_thread(mddev->sync_thread);
  4384. }
  4385. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  4386. md_wakeup_thread(mddev->thread);
  4387. sysfs_notify_dirent_safe(mddev->sysfs_action);
  4388. return len;
  4389. }
  4390. static struct md_sysfs_entry md_scan_mode =
  4391. __ATTR_PREALLOC(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
  4392. static ssize_t
  4393. last_sync_action_show(struct mddev *mddev, char *page)
  4394. {
  4395. return sprintf(page, "%s\n", mddev->last_sync_action);
  4396. }
  4397. static struct md_sysfs_entry md_last_scan_mode = __ATTR_RO(last_sync_action);
  4398. static ssize_t
  4399. mismatch_cnt_show(struct mddev *mddev, char *page)
  4400. {
  4401. return sprintf(page, "%llu\n",
  4402. (unsigned long long)
  4403. atomic64_read(&mddev->resync_mismatches));
  4404. }
  4405. static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
  4406. static ssize_t
  4407. sync_min_show(struct mddev *mddev, char *page)
  4408. {
  4409. return sprintf(page, "%d (%s)\n", speed_min(mddev),
  4410. mddev->sync_speed_min ? "local": "system");
  4411. }
  4412. static ssize_t
  4413. sync_min_store(struct mddev *mddev, const char *buf, size_t len)
  4414. {
  4415. unsigned int min;
  4416. int rv;
  4417. if (strncmp(buf, "system", 6)==0) {
  4418. min = 0;
  4419. } else {
  4420. rv = kstrtouint(buf, 10, &min);
  4421. if (rv < 0)
  4422. return rv;
  4423. if (min == 0)
  4424. return -EINVAL;
  4425. }
  4426. mddev->sync_speed_min = min;
  4427. return len;
  4428. }
  4429. static struct md_sysfs_entry md_sync_min =
  4430. __ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store);
  4431. static ssize_t
  4432. sync_max_show(struct mddev *mddev, char *page)
  4433. {
  4434. return sprintf(page, "%d (%s)\n", speed_max(mddev),
  4435. mddev->sync_speed_max ? "local": "system");
  4436. }
  4437. static ssize_t
  4438. sync_max_store(struct mddev *mddev, const char *buf, size_t len)
  4439. {
  4440. unsigned int max;
  4441. int rv;
  4442. if (strncmp(buf, "system", 6)==0) {
  4443. max = 0;
  4444. } else {
  4445. rv = kstrtouint(buf, 10, &max);
  4446. if (rv < 0)
  4447. return rv;
  4448. if (max == 0)
  4449. return -EINVAL;
  4450. }
  4451. mddev->sync_speed_max = max;
  4452. return len;
  4453. }
  4454. static struct md_sysfs_entry md_sync_max =
  4455. __ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store);
  4456. static ssize_t
  4457. degraded_show(struct mddev *mddev, char *page)
  4458. {
  4459. return sprintf(page, "%d\n", mddev->degraded);
  4460. }
  4461. static struct md_sysfs_entry md_degraded = __ATTR_RO(degraded);
  4462. static ssize_t
  4463. sync_force_parallel_show(struct mddev *mddev, char *page)
  4464. {
  4465. return sprintf(page, "%d\n", mddev->parallel_resync);
  4466. }
  4467. static ssize_t
  4468. sync_force_parallel_store(struct mddev *mddev, const char *buf, size_t len)
  4469. {
  4470. long n;
  4471. if (kstrtol(buf, 10, &n))
  4472. return -EINVAL;
  4473. if (n != 0 && n != 1)
  4474. return -EINVAL;
  4475. mddev->parallel_resync = n;
  4476. if (mddev->sync_thread)
  4477. wake_up(&resync_wait);
  4478. return len;
  4479. }
  4480. /* force parallel resync, even with shared block devices */
  4481. static struct md_sysfs_entry md_sync_force_parallel =
  4482. __ATTR(sync_force_parallel, S_IRUGO|S_IWUSR,
  4483. sync_force_parallel_show, sync_force_parallel_store);
  4484. static ssize_t
  4485. sync_speed_show(struct mddev *mddev, char *page)
  4486. {
  4487. unsigned long resync, dt, db;
  4488. if (mddev->curr_resync == 0)
  4489. return sprintf(page, "none\n");
  4490. resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active);
  4491. dt = (jiffies - mddev->resync_mark) / HZ;
  4492. if (!dt) dt++;
  4493. db = resync - mddev->resync_mark_cnt;
  4494. return sprintf(page, "%lu\n", db/dt/2); /* K/sec */
  4495. }
  4496. static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
  4497. static ssize_t
  4498. sync_completed_show(struct mddev *mddev, char *page)
  4499. {
  4500. unsigned long long max_sectors, resync;
  4501. if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
  4502. return sprintf(page, "none\n");
  4503. if (mddev->curr_resync == 1 ||
  4504. mddev->curr_resync == 2)
  4505. return sprintf(page, "delayed\n");
  4506. if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
  4507. test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
  4508. max_sectors = mddev->resync_max_sectors;
  4509. else
  4510. max_sectors = mddev->dev_sectors;
  4511. resync = mddev->curr_resync_completed;
  4512. return sprintf(page, "%llu / %llu\n", resync, max_sectors);
  4513. }
  4514. static struct md_sysfs_entry md_sync_completed =
  4515. __ATTR_PREALLOC(sync_completed, S_IRUGO, sync_completed_show, NULL);
  4516. static ssize_t
  4517. min_sync_show(struct mddev *mddev, char *page)
  4518. {
  4519. return sprintf(page, "%llu\n",
  4520. (unsigned long long)mddev->resync_min);
  4521. }
  4522. static ssize_t
  4523. min_sync_store(struct mddev *mddev, const char *buf, size_t len)
  4524. {
  4525. unsigned long long min;
  4526. int err;
  4527. if (kstrtoull(buf, 10, &min))
  4528. return -EINVAL;
  4529. spin_lock(&mddev->lock);
  4530. err = -EINVAL;
  4531. if (min > mddev->resync_max)
  4532. goto out_unlock;
  4533. err = -EBUSY;
  4534. if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
  4535. goto out_unlock;
  4536. /* Round down to multiple of 4K for safety */
  4537. mddev->resync_min = round_down(min, 8);
  4538. err = 0;
  4539. out_unlock:
  4540. spin_unlock(&mddev->lock);
  4541. return err ?: len;
  4542. }
  4543. static struct md_sysfs_entry md_min_sync =
  4544. __ATTR(sync_min, S_IRUGO|S_IWUSR, min_sync_show, min_sync_store);
  4545. static ssize_t
  4546. max_sync_show(struct mddev *mddev, char *page)
  4547. {
  4548. if (mddev->resync_max == MaxSector)
  4549. return sprintf(page, "max\n");
  4550. else
  4551. return sprintf(page, "%llu\n",
  4552. (unsigned long long)mddev->resync_max);
  4553. }
  4554. static ssize_t
  4555. max_sync_store(struct mddev *mddev, const char *buf, size_t len)
  4556. {
  4557. int err;
  4558. spin_lock(&mddev->lock);
  4559. if (strncmp(buf, "max", 3) == 0)
  4560. mddev->resync_max = MaxSector;
  4561. else {
  4562. unsigned long long max;
  4563. int chunk;
  4564. err = -EINVAL;
  4565. if (kstrtoull(buf, 10, &max))
  4566. goto out_unlock;
  4567. if (max < mddev->resync_min)
  4568. goto out_unlock;
  4569. err = -EBUSY;
  4570. if (max < mddev->resync_max &&
  4571. mddev->ro == 0 &&
  4572. test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
  4573. goto out_unlock;
  4574. /* Must be a multiple of chunk_size */
  4575. chunk = mddev->chunk_sectors;
  4576. if (chunk) {
  4577. sector_t temp = max;
  4578. err = -EINVAL;
  4579. if (sector_div(temp, chunk))
  4580. goto out_unlock;
  4581. }
  4582. mddev->resync_max = max;
  4583. }
  4584. wake_up(&mddev->recovery_wait);
  4585. err = 0;
  4586. out_unlock:
  4587. spin_unlock(&mddev->lock);
  4588. return err ?: len;
  4589. }
  4590. static struct md_sysfs_entry md_max_sync =
  4591. __ATTR(sync_max, S_IRUGO|S_IWUSR, max_sync_show, max_sync_store);
  4592. static ssize_t
  4593. suspend_lo_show(struct mddev *mddev, char *page)
  4594. {
  4595. return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
  4596. }
  4597. static ssize_t
  4598. suspend_lo_store(struct mddev *mddev, const char *buf, size_t len)
  4599. {
  4600. unsigned long long new;
  4601. int err;
  4602. err = kstrtoull(buf, 10, &new);
  4603. if (err < 0)
  4604. return err;
  4605. if (new != (sector_t)new)
  4606. return -EINVAL;
  4607. err = mddev_lock(mddev);
  4608. if (err)
  4609. return err;
  4610. err = -EINVAL;
  4611. if (mddev->pers == NULL ||
  4612. mddev->pers->quiesce == NULL)
  4613. goto unlock;
  4614. mddev_suspend(mddev);
  4615. mddev->suspend_lo = new;
  4616. mddev_resume(mddev);
  4617. err = 0;
  4618. unlock:
  4619. mddev_unlock(mddev);
  4620. return err ?: len;
  4621. }
  4622. static struct md_sysfs_entry md_suspend_lo =
  4623. __ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);
  4624. static ssize_t
  4625. suspend_hi_show(struct mddev *mddev, char *page)
  4626. {
  4627. return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
  4628. }
  4629. static ssize_t
  4630. suspend_hi_store(struct mddev *mddev, const char *buf, size_t len)
  4631. {
  4632. unsigned long long new;
  4633. int err;
  4634. err = kstrtoull(buf, 10, &new);
  4635. if (err < 0)
  4636. return err;
  4637. if (new != (sector_t)new)
  4638. return -EINVAL;
  4639. err = mddev_lock(mddev);
  4640. if (err)
  4641. return err;
  4642. err = -EINVAL;
  4643. if (mddev->pers == NULL)
  4644. goto unlock;
  4645. mddev_suspend(mddev);
  4646. mddev->suspend_hi = new;
  4647. mddev_resume(mddev);
  4648. err = 0;
  4649. unlock:
  4650. mddev_unlock(mddev);
  4651. return err ?: len;
  4652. }
  4653. static struct md_sysfs_entry md_suspend_hi =
  4654. __ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);
  4655. static ssize_t
  4656. reshape_position_show(struct mddev *mddev, char *page)
  4657. {
  4658. if (mddev->reshape_position != MaxSector)
  4659. return sprintf(page, "%llu\n",
  4660. (unsigned long long)mddev->reshape_position);
  4661. strcpy(page, "none\n");
  4662. return 5;
  4663. }
  4664. static ssize_t
  4665. reshape_position_store(struct mddev *mddev, const char *buf, size_t len)
  4666. {
  4667. struct md_rdev *rdev;
  4668. unsigned long long new;
  4669. int err;
  4670. err = kstrtoull(buf, 10, &new);
  4671. if (err < 0)
  4672. return err;
  4673. if (new != (sector_t)new)
  4674. return -EINVAL;
  4675. err = mddev_lock(mddev);
  4676. if (err)
  4677. return err;
  4678. err = -EBUSY;
  4679. if (mddev->pers)
  4680. goto unlock;
  4681. mddev->reshape_position = new;
  4682. mddev->delta_disks = 0;
  4683. mddev->reshape_backwards = 0;
  4684. mddev->new_level = mddev->level;
  4685. mddev->new_layout = mddev->layout;
  4686. mddev->new_chunk_sectors = mddev->chunk_sectors;
  4687. rdev_for_each(rdev, mddev)
  4688. rdev->new_data_offset = rdev->data_offset;
  4689. err = 0;
  4690. unlock:
  4691. mddev_unlock(mddev);
  4692. return err ?: len;
  4693. }
  4694. static struct md_sysfs_entry md_reshape_position =
  4695. __ATTR(reshape_position, S_IRUGO|S_IWUSR, reshape_position_show,
  4696. reshape_position_store);
  4697. static ssize_t
  4698. reshape_direction_show(struct mddev *mddev, char *page)
  4699. {
  4700. return sprintf(page, "%s\n",
  4701. mddev->reshape_backwards ? "backwards" : "forwards");
  4702. }
  4703. static ssize_t
  4704. reshape_direction_store(struct mddev *mddev, const char *buf, size_t len)
  4705. {
  4706. int backwards = 0;
  4707. int err;
  4708. if (cmd_match(buf, "forwards"))
  4709. backwards = 0;
  4710. else if (cmd_match(buf, "backwards"))
  4711. backwards = 1;
  4712. else
  4713. return -EINVAL;
  4714. if (mddev->reshape_backwards == backwards)
  4715. return len;
  4716. err = mddev_lock(mddev);
  4717. if (err)
  4718. return err;
  4719. /* check if we are allowed to change */
  4720. if (mddev->delta_disks)
  4721. err = -EBUSY;
  4722. else if (mddev->persistent &&
  4723. mddev->major_version == 0)
  4724. err = -EINVAL;
  4725. else
  4726. mddev->reshape_backwards = backwards;
  4727. mddev_unlock(mddev);
  4728. return err ?: len;
  4729. }
  4730. static struct md_sysfs_entry md_reshape_direction =
  4731. __ATTR(reshape_direction, S_IRUGO|S_IWUSR, reshape_direction_show,
  4732. reshape_direction_store);
  4733. static ssize_t
  4734. array_size_show(struct mddev *mddev, char *page)
  4735. {
  4736. if (mddev->external_size)
  4737. return sprintf(page, "%llu\n",
  4738. (unsigned long long)mddev->array_sectors/2);
  4739. else
  4740. return sprintf(page, "default\n");
  4741. }
  4742. static ssize_t
  4743. array_size_store(struct mddev *mddev, const char *buf, size_t len)
  4744. {
  4745. sector_t sectors;
  4746. int err;
  4747. err = mddev_lock(mddev);
  4748. if (err)
  4749. return err;
  4750. /* cluster raid doesn't support change array_sectors */
  4751. if (mddev_is_clustered(mddev)) {
  4752. mddev_unlock(mddev);
  4753. return -EINVAL;
  4754. }
  4755. if (strncmp(buf, "default", 7) == 0) {
  4756. if (mddev->pers)
  4757. sectors = mddev->pers->size(mddev, 0, 0);
  4758. else
  4759. sectors = mddev->array_sectors;
  4760. mddev->external_size = 0;
  4761. } else {
  4762. if (strict_blocks_to_sectors(buf, &sectors) < 0)
  4763. err = -EINVAL;
  4764. else if (mddev->pers && mddev->pers->size(mddev, 0, 0) < sectors)
  4765. err = -E2BIG;
  4766. else
  4767. mddev->external_size = 1;
  4768. }
  4769. if (!err) {
  4770. mddev->array_sectors = sectors;
  4771. if (mddev->pers) {
  4772. set_capacity(mddev->gendisk, mddev->array_sectors);
  4773. revalidate_disk_size(mddev->gendisk, true);
  4774. }
  4775. }
  4776. mddev_unlock(mddev);
  4777. return err ?: len;
  4778. }
  4779. static struct md_sysfs_entry md_array_size =
  4780. __ATTR(array_size, S_IRUGO|S_IWUSR, array_size_show,
  4781. array_size_store);
  4782. static ssize_t
  4783. consistency_policy_show(struct mddev *mddev, char *page)
  4784. {
  4785. int ret;
  4786. if (test_bit(MD_HAS_JOURNAL, &mddev->flags)) {
  4787. ret = sprintf(page, "journal\n");
  4788. } else if (test_bit(MD_HAS_PPL, &mddev->flags)) {
  4789. ret = sprintf(page, "ppl\n");
  4790. } else if (mddev->bitmap) {
  4791. ret = sprintf(page, "bitmap\n");
  4792. } else if (mddev->pers) {
  4793. if (mddev->pers->sync_request)
  4794. ret = sprintf(page, "resync\n");
  4795. else
  4796. ret = sprintf(page, "none\n");
  4797. } else {
  4798. ret = sprintf(page, "unknown\n");
  4799. }
  4800. return ret;
  4801. }
  4802. static ssize_t
  4803. consistency_policy_store(struct mddev *mddev, const char *buf, size_t len)
  4804. {
  4805. int err = 0;
  4806. if (mddev->pers) {
  4807. if (mddev->pers->change_consistency_policy)
  4808. err = mddev->pers->change_consistency_policy(mddev, buf);
  4809. else
  4810. err = -EBUSY;
  4811. } else if (mddev->external && strncmp(buf, "ppl", 3) == 0) {
  4812. set_bit(MD_HAS_PPL, &mddev->flags);
  4813. } else {
  4814. err = -EINVAL;
  4815. }
  4816. return err ? err : len;
  4817. }
  4818. static struct md_sysfs_entry md_consistency_policy =
  4819. __ATTR(consistency_policy, S_IRUGO | S_IWUSR, consistency_policy_show,
  4820. consistency_policy_store);
  4821. static ssize_t fail_last_dev_show(struct mddev *mddev, char *page)
  4822. {
  4823. return sprintf(page, "%d\n", mddev->fail_last_dev);
  4824. }
  4825. /*
  4826. * Setting fail_last_dev to true to allow last device to be forcibly removed
  4827. * from RAID1/RAID10.
  4828. */
  4829. static ssize_t
  4830. fail_last_dev_store(struct mddev *mddev, const char *buf, size_t len)
  4831. {
  4832. int ret;
  4833. bool value;
  4834. ret = kstrtobool(buf, &value);
  4835. if (ret)
  4836. return ret;
  4837. if (value != mddev->fail_last_dev)
  4838. mddev->fail_last_dev = value;
  4839. return len;
  4840. }
  4841. static struct md_sysfs_entry md_fail_last_dev =
  4842. __ATTR(fail_last_dev, S_IRUGO | S_IWUSR, fail_last_dev_show,
  4843. fail_last_dev_store);
  4844. static ssize_t serialize_policy_show(struct mddev *mddev, char *page)
  4845. {
  4846. if (mddev->pers == NULL || (mddev->pers->level != 1))
  4847. return sprintf(page, "n/a\n");
  4848. else
  4849. return sprintf(page, "%d\n", mddev->serialize_policy);
  4850. }
  4851. /*
  4852. * Setting serialize_policy to true to enforce write IO is not reordered
  4853. * for raid1.
  4854. */
  4855. static ssize_t
  4856. serialize_policy_store(struct mddev *mddev, const char *buf, size_t len)
  4857. {
  4858. int err;
  4859. bool value;
  4860. err = kstrtobool(buf, &value);
  4861. if (err)
  4862. return err;
  4863. if (value == mddev->serialize_policy)
  4864. return len;
  4865. err = mddev_lock(mddev);
  4866. if (err)
  4867. return err;
  4868. if (mddev->pers == NULL || (mddev->pers->level != 1)) {
  4869. pr_err("md: serialize_policy is only effective for raid1\n");
  4870. err = -EINVAL;
  4871. goto unlock;
  4872. }
  4873. mddev_suspend(mddev);
  4874. if (value)
  4875. mddev_create_serial_pool(mddev, NULL, true);
  4876. else
  4877. mddev_destroy_serial_pool(mddev, NULL, true);
  4878. mddev->serialize_policy = value;
  4879. mddev_resume(mddev);
  4880. unlock:
  4881. mddev_unlock(mddev);
  4882. return err ?: len;
  4883. }
  4884. static struct md_sysfs_entry md_serialize_policy =
  4885. __ATTR(serialize_policy, S_IRUGO | S_IWUSR, serialize_policy_show,
  4886. serialize_policy_store);
  4887. static struct attribute *md_default_attrs[] = {
  4888. &md_level.attr,
  4889. &md_layout.attr,
  4890. &md_raid_disks.attr,
  4891. &md_uuid.attr,
  4892. &md_chunk_size.attr,
  4893. &md_size.attr,
  4894. &md_resync_start.attr,
  4895. &md_metadata.attr,
  4896. &md_new_device.attr,
  4897. &md_safe_delay.attr,
  4898. &md_array_state.attr,
  4899. &md_reshape_position.attr,
  4900. &md_reshape_direction.attr,
  4901. &md_array_size.attr,
  4902. &max_corr_read_errors.attr,
  4903. &md_consistency_policy.attr,
  4904. &md_fail_last_dev.attr,
  4905. &md_serialize_policy.attr,
  4906. NULL,
  4907. };
  4908. static struct attribute *md_redundancy_attrs[] = {
  4909. &md_scan_mode.attr,
  4910. &md_last_scan_mode.attr,
  4911. &md_mismatches.attr,
  4912. &md_sync_min.attr,
  4913. &md_sync_max.attr,
  4914. &md_sync_speed.attr,
  4915. &md_sync_force_parallel.attr,
  4916. &md_sync_completed.attr,
  4917. &md_min_sync.attr,
  4918. &md_max_sync.attr,
  4919. &md_suspend_lo.attr,
  4920. &md_suspend_hi.attr,
  4921. &md_bitmap.attr,
  4922. &md_degraded.attr,
  4923. NULL,
  4924. };
  4925. static struct attribute_group md_redundancy_group = {
  4926. .name = NULL,
  4927. .attrs = md_redundancy_attrs,
  4928. };
  4929. static ssize_t
  4930. md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
  4931. {
  4932. struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
  4933. struct mddev *mddev = container_of(kobj, struct mddev, kobj);
  4934. ssize_t rv;
  4935. if (!entry->show)
  4936. return -EIO;
  4937. spin_lock(&all_mddevs_lock);
  4938. if (list_empty(&mddev->all_mddevs)) {
  4939. spin_unlock(&all_mddevs_lock);
  4940. return -EBUSY;
  4941. }
  4942. mddev_get(mddev);
  4943. spin_unlock(&all_mddevs_lock);
  4944. rv = entry->show(mddev, page);
  4945. mddev_put(mddev);
  4946. return rv;
  4947. }
  4948. static ssize_t
  4949. md_attr_store(struct kobject *kobj, struct attribute *attr,
  4950. const char *page, size_t length)
  4951. {
  4952. struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
  4953. struct mddev *mddev = container_of(kobj, struct mddev, kobj);
  4954. ssize_t rv;
  4955. if (!entry->store)
  4956. return -EIO;
  4957. if (!capable(CAP_SYS_ADMIN))
  4958. return -EACCES;
  4959. spin_lock(&all_mddevs_lock);
  4960. if (list_empty(&mddev->all_mddevs)) {
  4961. spin_unlock(&all_mddevs_lock);
  4962. return -EBUSY;
  4963. }
  4964. mddev_get(mddev);
  4965. spin_unlock(&all_mddevs_lock);
  4966. rv = entry->store(mddev, page, length);
  4967. mddev_put(mddev);
  4968. return rv;
  4969. }
  4970. static void md_free(struct kobject *ko)
  4971. {
  4972. struct mddev *mddev = container_of(ko, struct mddev, kobj);
  4973. if (mddev->sysfs_state)
  4974. sysfs_put(mddev->sysfs_state);
  4975. if (mddev->sysfs_level)
  4976. sysfs_put(mddev->sysfs_level);
  4977. if (mddev->gendisk)
  4978. del_gendisk(mddev->gendisk);
  4979. if (mddev->queue)
  4980. blk_cleanup_queue(mddev->queue);
  4981. if (mddev->gendisk)
  4982. put_disk(mddev->gendisk);
  4983. percpu_ref_exit(&mddev->writes_pending);
  4984. bioset_exit(&mddev->bio_set);
  4985. bioset_exit(&mddev->sync_set);
  4986. kfree(mddev);
  4987. }
  4988. static const struct sysfs_ops md_sysfs_ops = {
  4989. .show = md_attr_show,
  4990. .store = md_attr_store,
  4991. };
  4992. static struct kobj_type md_ktype = {
  4993. .release = md_free,
  4994. .sysfs_ops = &md_sysfs_ops,
  4995. .default_attrs = md_default_attrs,
  4996. };
  4997. int mdp_major = 0;
  4998. static void mddev_delayed_delete(struct work_struct *ws)
  4999. {
  5000. struct mddev *mddev = container_of(ws, struct mddev, del_work);
  5001. sysfs_remove_group(&mddev->kobj, &md_bitmap_group);
  5002. kobject_del(&mddev->kobj);
  5003. kobject_put(&mddev->kobj);
  5004. }
  5005. static void no_op(struct percpu_ref *r) {}
  5006. int mddev_init_writes_pending(struct mddev *mddev)
  5007. {
  5008. if (mddev->writes_pending.percpu_count_ptr)
  5009. return 0;
  5010. if (percpu_ref_init(&mddev->writes_pending, no_op,
  5011. PERCPU_REF_ALLOW_REINIT, GFP_KERNEL) < 0)
  5012. return -ENOMEM;
  5013. /* We want to start with the refcount at zero */
  5014. percpu_ref_put(&mddev->writes_pending);
  5015. return 0;
  5016. }
  5017. EXPORT_SYMBOL_GPL(mddev_init_writes_pending);
  5018. static int md_alloc(dev_t dev, char *name)
  5019. {
  5020. /*
  5021. * If dev is zero, name is the name of a device to allocate with
  5022. * an arbitrary minor number. It will be "md_???"
  5023. * If dev is non-zero it must be a device number with a MAJOR of
  5024. * MD_MAJOR or mdp_major. In this case, if "name" is NULL, then
  5025. * the device is being created by opening a node in /dev.
  5026. * If "name" is not NULL, the device is being created by
  5027. * writing to /sys/module/md_mod/parameters/new_array.
  5028. */
  5029. static DEFINE_MUTEX(disks_mutex);
  5030. struct mddev *mddev = mddev_find_or_alloc(dev);
  5031. struct gendisk *disk;
  5032. int partitioned;
  5033. int shift;
  5034. int unit;
  5035. int error;
  5036. if (!mddev)
  5037. return -ENODEV;
  5038. partitioned = (MAJOR(mddev->unit) != MD_MAJOR);
  5039. shift = partitioned ? MdpMinorShift : 0;
  5040. unit = MINOR(mddev->unit) >> shift;
  5041. /* wait for any previous instance of this device to be
  5042. * completely removed (mddev_delayed_delete).
  5043. */
  5044. flush_workqueue(md_misc_wq);
  5045. mutex_lock(&disks_mutex);
  5046. error = -EEXIST;
  5047. if (mddev->gendisk)
  5048. goto abort;
  5049. if (name && !dev) {
  5050. /* Need to ensure that 'name' is not a duplicate.
  5051. */
  5052. struct mddev *mddev2;
  5053. spin_lock(&all_mddevs_lock);
  5054. list_for_each_entry(mddev2, &all_mddevs, all_mddevs)
  5055. if (mddev2->gendisk &&
  5056. strcmp(mddev2->gendisk->disk_name, name) == 0) {
  5057. spin_unlock(&all_mddevs_lock);
  5058. goto abort;
  5059. }
  5060. spin_unlock(&all_mddevs_lock);
  5061. }
  5062. if (name && dev)
  5063. /*
  5064. * Creating /dev/mdNNN via "newarray", so adjust hold_active.
  5065. */
  5066. mddev->hold_active = UNTIL_STOP;
  5067. error = -ENOMEM;
  5068. mddev->queue = blk_alloc_queue(NUMA_NO_NODE);
  5069. if (!mddev->queue)
  5070. goto abort;
  5071. blk_set_stacking_limits(&mddev->queue->limits);
  5072. disk = alloc_disk(1 << shift);
  5073. if (!disk) {
  5074. blk_cleanup_queue(mddev->queue);
  5075. mddev->queue = NULL;
  5076. goto abort;
  5077. }
  5078. disk->major = MAJOR(mddev->unit);
  5079. disk->first_minor = unit << shift;
  5080. if (name)
  5081. strcpy(disk->disk_name, name);
  5082. else if (partitioned)
  5083. sprintf(disk->disk_name, "md_d%d", unit);
  5084. else
  5085. sprintf(disk->disk_name, "md%d", unit);
  5086. disk->fops = &md_fops;
  5087. disk->private_data = mddev;
  5088. disk->queue = mddev->queue;
  5089. blk_queue_write_cache(mddev->queue, true, true);
  5090. /* Allow extended partitions. This makes the
  5091. * 'mdp' device redundant, but we can't really
  5092. * remove it now.
  5093. */
  5094. disk->flags |= GENHD_FL_EXT_DEVT;
  5095. disk->events |= DISK_EVENT_MEDIA_CHANGE;
  5096. mddev->gendisk = disk;
  5097. add_disk(disk);
  5098. error = kobject_add(&mddev->kobj, &disk_to_dev(disk)->kobj, "%s", "md");
  5099. if (error) {
  5100. /* This isn't possible, but as kobject_init_and_add is marked
  5101. * __must_check, we must do something with the result
  5102. */
  5103. pr_debug("md: cannot register %s/md - name in use\n",
  5104. disk->disk_name);
  5105. error = 0;
  5106. }
  5107. if (mddev->kobj.sd &&
  5108. sysfs_create_group(&mddev->kobj, &md_bitmap_group))
  5109. pr_debug("pointless warning\n");
  5110. abort:
  5111. mutex_unlock(&disks_mutex);
  5112. if (!error && mddev->kobj.sd) {
  5113. kobject_uevent(&mddev->kobj, KOBJ_ADD);
  5114. mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");
  5115. mddev->sysfs_level = sysfs_get_dirent_safe(mddev->kobj.sd, "level");
  5116. }
  5117. mddev_put(mddev);
  5118. return error;
  5119. }
  5120. static struct kobject *md_probe(dev_t dev, int *part, void *data)
  5121. {
  5122. if (create_on_open)
  5123. md_alloc(dev, NULL);
  5124. return NULL;
  5125. }
  5126. static int add_named_array(const char *val, const struct kernel_param *kp)
  5127. {
  5128. /*
  5129. * val must be "md_*" or "mdNNN".
  5130. * For "md_*" we allocate an array with a large free minor number, and
  5131. * set the name to val. val must not already be an active name.
  5132. * For "mdNNN" we allocate an array with the minor number NNN
  5133. * which must not already be in use.
  5134. */
  5135. int len = strlen(val);
  5136. char buf[DISK_NAME_LEN];
  5137. unsigned long devnum;
  5138. while (len && val[len-1] == '\n')
  5139. len--;
  5140. if (len >= DISK_NAME_LEN)
  5141. return -E2BIG;
  5142. strlcpy(buf, val, len+1);
  5143. if (strncmp(buf, "md_", 3) == 0)
  5144. return md_alloc(0, buf);
  5145. if (strncmp(buf, "md", 2) == 0 &&
  5146. isdigit(buf[2]) &&
  5147. kstrtoul(buf+2, 10, &devnum) == 0 &&
  5148. devnum <= MINORMASK)
  5149. return md_alloc(MKDEV(MD_MAJOR, devnum), NULL);
  5150. return -EINVAL;
  5151. }
  5152. static void md_safemode_timeout(struct timer_list *t)
  5153. {
  5154. struct mddev *mddev = from_timer(mddev, t, safemode_timer);
  5155. mddev->safemode = 1;
  5156. if (mddev->external)
  5157. sysfs_notify_dirent_safe(mddev->sysfs_state);
  5158. md_wakeup_thread(mddev->thread);
  5159. }
  5160. static int start_dirty_degraded;
  5161. int md_run(struct mddev *mddev)
  5162. {
  5163. int err;
  5164. struct md_rdev *rdev;
  5165. struct md_personality *pers;
  5166. if (list_empty(&mddev->disks))
  5167. /* cannot run an array with no devices.. */
  5168. return -EINVAL;
  5169. if (mddev->pers)
  5170. return -EBUSY;
  5171. /* Cannot run until previous stop completes properly */
  5172. if (mddev->sysfs_active)
  5173. return -EBUSY;
  5174. /*
  5175. * Analyze all RAID superblock(s)
  5176. */
  5177. if (!mddev->raid_disks) {
  5178. if (!mddev->persistent)
  5179. return -EINVAL;
  5180. err = analyze_sbs(mddev);
  5181. if (err)
  5182. return -EINVAL;
  5183. }
  5184. if (mddev->level != LEVEL_NONE)
  5185. request_module("md-level-%d", mddev->level);
  5186. else if (mddev->clevel[0])
  5187. request_module("md-%s", mddev->clevel);
  5188. /*
  5189. * Drop all container device buffers, from now on
  5190. * the only valid external interface is through the md
  5191. * device.
  5192. */
  5193. mddev->has_superblocks = false;
  5194. rdev_for_each(rdev, mddev) {
  5195. if (test_bit(Faulty, &rdev->flags))
  5196. continue;
  5197. sync_blockdev(rdev->bdev);
  5198. invalidate_bdev(rdev->bdev);
  5199. if (mddev->ro != 1 &&
  5200. (bdev_read_only(rdev->bdev) ||
  5201. bdev_read_only(rdev->meta_bdev))) {
  5202. mddev->ro = 1;
  5203. if (mddev->gendisk)
  5204. set_disk_ro(mddev->gendisk, 1);
  5205. }
  5206. if (rdev->sb_page)
  5207. mddev->has_superblocks = true;
  5208. /* perform some consistency tests on the device.
  5209. * We don't want the data to overlap the metadata,
  5210. * Internal Bitmap issues have been handled elsewhere.
  5211. */
  5212. if (rdev->meta_bdev) {
  5213. /* Nothing to check */;
  5214. } else if (rdev->data_offset < rdev->sb_start) {
  5215. if (mddev->dev_sectors &&
  5216. rdev->data_offset + mddev->dev_sectors
  5217. > rdev->sb_start) {
  5218. pr_warn("md: %s: data overlaps metadata\n",
  5219. mdname(mddev));
  5220. return -EINVAL;
  5221. }
  5222. } else {
  5223. if (rdev->sb_start + rdev->sb_size/512
  5224. > rdev->data_offset) {
  5225. pr_warn("md: %s: metadata overlaps data\n",
  5226. mdname(mddev));
  5227. return -EINVAL;
  5228. }
  5229. }
  5230. sysfs_notify_dirent_safe(rdev->sysfs_state);
  5231. }
  5232. if (!bioset_initialized(&mddev->bio_set)) {
  5233. err = bioset_init(&mddev->bio_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS);
  5234. if (err)
  5235. return err;
  5236. }
  5237. if (!bioset_initialized(&mddev->sync_set)) {
  5238. err = bioset_init(&mddev->sync_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS);
  5239. if (err)
  5240. return err;
  5241. }
  5242. spin_lock(&pers_lock);
  5243. pers = find_pers(mddev->level, mddev->clevel);
  5244. if (!pers || !try_module_get(pers->owner)) {
  5245. spin_unlock(&pers_lock);
  5246. if (mddev->level != LEVEL_NONE)
  5247. pr_warn("md: personality for level %d is not loaded!\n",
  5248. mddev->level);
  5249. else
  5250. pr_warn("md: personality for level %s is not loaded!\n",
  5251. mddev->clevel);
  5252. err = -EINVAL;
  5253. goto abort;
  5254. }
  5255. spin_unlock(&pers_lock);
  5256. if (mddev->level != pers->level) {
  5257. mddev->level = pers->level;
  5258. mddev->new_level = pers->level;
  5259. }
  5260. strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
  5261. if (mddev->reshape_position != MaxSector &&
  5262. pers->start_reshape == NULL) {
  5263. /* This personality cannot handle reshaping... */
  5264. module_put(pers->owner);
  5265. err = -EINVAL;
  5266. goto abort;
  5267. }
  5268. if (pers->sync_request) {
  5269. /* Warn if this is a potentially silly
  5270. * configuration.
  5271. */
  5272. char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
  5273. struct md_rdev *rdev2;
  5274. int warned = 0;
  5275. rdev_for_each(rdev, mddev)
  5276. rdev_for_each(rdev2, mddev) {
  5277. if (rdev < rdev2 &&
  5278. rdev->bdev->bd_disk ==
  5279. rdev2->bdev->bd_disk) {
  5280. pr_warn("%s: WARNING: %s appears to be on the same physical disk as %s.\n",
  5281. mdname(mddev),
  5282. bdevname(rdev->bdev,b),
  5283. bdevname(rdev2->bdev,b2));
  5284. warned = 1;
  5285. }
  5286. }
  5287. if (warned)
  5288. pr_warn("True protection against single-disk failure might be compromised.\n");
  5289. }
  5290. mddev->recovery = 0;
  5291. /* may be over-ridden by personality */
  5292. mddev->resync_max_sectors = mddev->dev_sectors;
  5293. mddev->ok_start_degraded = start_dirty_degraded;
  5294. if (start_readonly && mddev->ro == 0)
  5295. mddev->ro = 2; /* read-only, but switch on first write */
  5296. err = pers->run(mddev);
  5297. if (err)
  5298. pr_warn("md: pers->run() failed ...\n");
  5299. else if (pers->size(mddev, 0, 0) < mddev->array_sectors) {
  5300. WARN_ONCE(!mddev->external_size,
  5301. "%s: default size too small, but 'external_size' not in effect?\n",
  5302. __func__);
  5303. pr_warn("md: invalid array_size %llu > default size %llu\n",
  5304. (unsigned long long)mddev->array_sectors / 2,
  5305. (unsigned long long)pers->size(mddev, 0, 0) / 2);
  5306. err = -EINVAL;
  5307. }
  5308. if (err == 0 && pers->sync_request &&
  5309. (mddev->bitmap_info.file || mddev->bitmap_info.offset)) {
  5310. struct bitmap *bitmap;
  5311. bitmap = md_bitmap_create(mddev, -1);
  5312. if (IS_ERR(bitmap)) {
  5313. err = PTR_ERR(bitmap);
  5314. pr_warn("%s: failed to create bitmap (%d)\n",
  5315. mdname(mddev), err);
  5316. } else
  5317. mddev->bitmap = bitmap;
  5318. }
  5319. if (err)
  5320. goto bitmap_abort;
  5321. if (mddev->bitmap_info.max_write_behind > 0) {
  5322. bool create_pool = false;
  5323. rdev_for_each(rdev, mddev) {
  5324. if (test_bit(WriteMostly, &rdev->flags) &&
  5325. rdev_init_serial(rdev))
  5326. create_pool = true;
  5327. }
  5328. if (create_pool && mddev->serial_info_pool == NULL) {
  5329. mddev->serial_info_pool =
  5330. mempool_create_kmalloc_pool(NR_SERIAL_INFOS,
  5331. sizeof(struct serial_info));
  5332. if (!mddev->serial_info_pool) {
  5333. err = -ENOMEM;
  5334. goto bitmap_abort;
  5335. }
  5336. }
  5337. }
  5338. if (mddev->queue) {
  5339. bool nonrot = true;
  5340. rdev_for_each(rdev, mddev) {
  5341. if (rdev->raid_disk >= 0 &&
  5342. !blk_queue_nonrot(bdev_get_queue(rdev->bdev))) {
  5343. nonrot = false;
  5344. break;
  5345. }
  5346. }
  5347. if (mddev->degraded)
  5348. nonrot = false;
  5349. if (nonrot)
  5350. blk_queue_flag_set(QUEUE_FLAG_NONROT, mddev->queue);
  5351. else
  5352. blk_queue_flag_clear(QUEUE_FLAG_NONROT, mddev->queue);
  5353. }
  5354. if (pers->sync_request) {
  5355. if (mddev->kobj.sd &&
  5356. sysfs_create_group(&mddev->kobj, &md_redundancy_group))
  5357. pr_warn("md: cannot register extra attributes for %s\n",
  5358. mdname(mddev));
  5359. mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action");
  5360. mddev->sysfs_completed = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_completed");
  5361. mddev->sysfs_degraded = sysfs_get_dirent_safe(mddev->kobj.sd, "degraded");
  5362. } else if (mddev->ro == 2) /* auto-readonly not meaningful */
  5363. mddev->ro = 0;
  5364. atomic_set(&mddev->max_corr_read_errors,
  5365. MD_DEFAULT_MAX_CORRECTED_READ_ERRORS);
  5366. mddev->safemode = 0;
  5367. if (mddev_is_clustered(mddev))
  5368. mddev->safemode_delay = 0;
  5369. else
  5370. mddev->safemode_delay = DEFAULT_SAFEMODE_DELAY;
  5371. mddev->in_sync = 1;
  5372. smp_wmb();
  5373. spin_lock(&mddev->lock);
  5374. mddev->pers = pers;
  5375. spin_unlock(&mddev->lock);
  5376. rdev_for_each(rdev, mddev)
  5377. if (rdev->raid_disk >= 0)
  5378. sysfs_link_rdev(mddev, rdev); /* failure here is OK */
  5379. if (mddev->degraded && !mddev->ro)
  5380. /* This ensures that recovering status is reported immediately
  5381. * via sysfs - until a lack of spares is confirmed.
  5382. */
  5383. set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
  5384. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  5385. if (mddev->sb_flags)
  5386. md_update_sb(mddev, 0);
  5387. md_new_event(mddev);
  5388. return 0;
  5389. bitmap_abort:
  5390. mddev_detach(mddev);
  5391. if (mddev->private)
  5392. pers->free(mddev, mddev->private);
  5393. mddev->private = NULL;
  5394. module_put(pers->owner);
  5395. md_bitmap_destroy(mddev);
  5396. abort:
  5397. bioset_exit(&mddev->bio_set);
  5398. bioset_exit(&mddev->sync_set);
  5399. return err;
  5400. }
  5401. EXPORT_SYMBOL_GPL(md_run);
  5402. int do_md_run(struct mddev *mddev)
  5403. {
  5404. int err;
  5405. set_bit(MD_NOT_READY, &mddev->flags);
  5406. err = md_run(mddev);
  5407. if (err)
  5408. goto out;
  5409. err = md_bitmap_load(mddev);
  5410. if (err) {
  5411. md_bitmap_destroy(mddev);
  5412. goto out;
  5413. }
  5414. if (mddev_is_clustered(mddev))
  5415. md_allow_write(mddev);
  5416. /* run start up tasks that require md_thread */
  5417. md_start(mddev);
  5418. md_wakeup_thread(mddev->thread);
  5419. md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
  5420. set_capacity(mddev->gendisk, mddev->array_sectors);
  5421. revalidate_disk_size(mddev->gendisk, true);
  5422. clear_bit(MD_NOT_READY, &mddev->flags);
  5423. mddev->changed = 1;
  5424. kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
  5425. sysfs_notify_dirent_safe(mddev->sysfs_state);
  5426. sysfs_notify_dirent_safe(mddev->sysfs_action);
  5427. sysfs_notify_dirent_safe(mddev->sysfs_degraded);
  5428. out:
  5429. clear_bit(MD_NOT_READY, &mddev->flags);
  5430. return err;
  5431. }
  5432. int md_start(struct mddev *mddev)
  5433. {
  5434. int ret = 0;
  5435. if (mddev->pers->start) {
  5436. set_bit(MD_RECOVERY_WAIT, &mddev->recovery);
  5437. md_wakeup_thread(mddev->thread);
  5438. ret = mddev->pers->start(mddev);
  5439. clear_bit(MD_RECOVERY_WAIT, &mddev->recovery);
  5440. md_wakeup_thread(mddev->sync_thread);
  5441. }
  5442. return ret;
  5443. }
  5444. EXPORT_SYMBOL_GPL(md_start);
  5445. static int restart_array(struct mddev *mddev)
  5446. {
  5447. struct gendisk *disk = mddev->gendisk;
  5448. struct md_rdev *rdev;
  5449. bool has_journal = false;
  5450. bool has_readonly = false;
  5451. /* Complain if it has no devices */
  5452. if (list_empty(&mddev->disks))
  5453. return -ENXIO;
  5454. if (!mddev->pers)
  5455. return -EINVAL;
  5456. if (!mddev->ro)
  5457. return -EBUSY;
  5458. rcu_read_lock();
  5459. rdev_for_each_rcu(rdev, mddev) {
  5460. if (test_bit(Journal, &rdev->flags) &&
  5461. !test_bit(Faulty, &rdev->flags))
  5462. has_journal = true;
  5463. if (bdev_read_only(rdev->bdev))
  5464. has_readonly = true;
  5465. }
  5466. rcu_read_unlock();
  5467. if (test_bit(MD_HAS_JOURNAL, &mddev->flags) && !has_journal)
  5468. /* Don't restart rw with journal missing/faulty */
  5469. return -EINVAL;
  5470. if (has_readonly)
  5471. return -EROFS;
  5472. mddev->safemode = 0;
  5473. mddev->ro = 0;
  5474. set_disk_ro(disk, 0);
  5475. pr_debug("md: %s switched to read-write mode.\n", mdname(mddev));
  5476. /* Kick recovery or resync if necessary */
  5477. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  5478. md_wakeup_thread(mddev->thread);
  5479. md_wakeup_thread(mddev->sync_thread);
  5480. sysfs_notify_dirent_safe(mddev->sysfs_state);
  5481. return 0;
  5482. }
  5483. static void md_clean(struct mddev *mddev)
  5484. {
  5485. mddev->array_sectors = 0;
  5486. mddev->external_size = 0;
  5487. mddev->dev_sectors = 0;
  5488. mddev->raid_disks = 0;
  5489. mddev->recovery_cp = 0;
  5490. mddev->resync_min = 0;
  5491. mddev->resync_max = MaxSector;
  5492. mddev->reshape_position = MaxSector;
  5493. mddev->external = 0;
  5494. mddev->persistent = 0;
  5495. mddev->level = LEVEL_NONE;
  5496. mddev->clevel[0] = 0;
  5497. mddev->flags = 0;
  5498. mddev->sb_flags = 0;
  5499. mddev->ro = 0;
  5500. mddev->metadata_type[0] = 0;
  5501. mddev->chunk_sectors = 0;
  5502. mddev->ctime = mddev->utime = 0;
  5503. mddev->layout = 0;
  5504. mddev->max_disks = 0;
  5505. mddev->events = 0;
  5506. mddev->can_decrease_events = 0;
  5507. mddev->delta_disks = 0;
  5508. mddev->reshape_backwards = 0;
  5509. mddev->new_level = LEVEL_NONE;
  5510. mddev->new_layout = 0;
  5511. mddev->new_chunk_sectors = 0;
  5512. mddev->curr_resync = 0;
  5513. atomic64_set(&mddev->resync_mismatches, 0);
  5514. mddev->suspend_lo = mddev->suspend_hi = 0;
  5515. mddev->sync_speed_min = mddev->sync_speed_max = 0;
  5516. mddev->recovery = 0;
  5517. mddev->in_sync = 0;
  5518. mddev->changed = 0;
  5519. mddev->degraded = 0;
  5520. mddev->safemode = 0;
  5521. mddev->private = NULL;
  5522. mddev->cluster_info = NULL;
  5523. mddev->bitmap_info.offset = 0;
  5524. mddev->bitmap_info.default_offset = 0;
  5525. mddev->bitmap_info.default_space = 0;
  5526. mddev->bitmap_info.chunksize = 0;
  5527. mddev->bitmap_info.daemon_sleep = 0;
  5528. mddev->bitmap_info.max_write_behind = 0;
  5529. mddev->bitmap_info.nodes = 0;
  5530. }
  5531. static void __md_stop_writes(struct mddev *mddev)
  5532. {
  5533. set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
  5534. if (work_pending(&mddev->del_work))
  5535. flush_workqueue(md_misc_wq);
  5536. if (mddev->sync_thread) {
  5537. set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  5538. md_reap_sync_thread(mddev);
  5539. }
  5540. del_timer_sync(&mddev->safemode_timer);
  5541. if (mddev->pers && mddev->pers->quiesce) {
  5542. mddev->pers->quiesce(mddev, 1);
  5543. mddev->pers->quiesce(mddev, 0);
  5544. }
  5545. md_bitmap_flush(mddev);
  5546. if (mddev->ro == 0 &&
  5547. ((!mddev->in_sync && !mddev_is_clustered(mddev)) ||
  5548. mddev->sb_flags)) {
  5549. /* mark array as shutdown cleanly */
  5550. if (!mddev_is_clustered(mddev))
  5551. mddev->in_sync = 1;
  5552. md_update_sb(mddev, 1);
  5553. }
  5554. /* disable policy to guarantee rdevs free resources for serialization */
  5555. mddev->serialize_policy = 0;
  5556. mddev_destroy_serial_pool(mddev, NULL, true);
  5557. }
  5558. void md_stop_writes(struct mddev *mddev)
  5559. {
  5560. mddev_lock_nointr(mddev);
  5561. __md_stop_writes(mddev);
  5562. mddev_unlock(mddev);
  5563. }
  5564. EXPORT_SYMBOL_GPL(md_stop_writes);
  5565. static void mddev_detach(struct mddev *mddev)
  5566. {
  5567. md_bitmap_wait_behind_writes(mddev);
  5568. if (mddev->pers && mddev->pers->quiesce && !mddev->suspended) {
  5569. mddev->pers->quiesce(mddev, 1);
  5570. mddev->pers->quiesce(mddev, 0);
  5571. }
  5572. md_unregister_thread(&mddev->thread);
  5573. if (mddev->queue)
  5574. blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
  5575. }
  5576. static void __md_stop(struct mddev *mddev)
  5577. {
  5578. struct md_personality *pers = mddev->pers;
  5579. md_bitmap_destroy(mddev);
  5580. mddev_detach(mddev);
  5581. /* Ensure ->event_work is done */
  5582. if (mddev->event_work.func)
  5583. flush_workqueue(md_misc_wq);
  5584. spin_lock(&mddev->lock);
  5585. mddev->pers = NULL;
  5586. spin_unlock(&mddev->lock);
  5587. pers->free(mddev, mddev->private);
  5588. mddev->private = NULL;
  5589. if (pers->sync_request && mddev->to_remove == NULL)
  5590. mddev->to_remove = &md_redundancy_group;
  5591. module_put(pers->owner);
  5592. clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
  5593. }
  5594. void md_stop(struct mddev *mddev)
  5595. {
  5596. /* stop the array and free an attached data structures.
  5597. * This is called from dm-raid
  5598. */
  5599. __md_stop(mddev);
  5600. bioset_exit(&mddev->bio_set);
  5601. bioset_exit(&mddev->sync_set);
  5602. }
  5603. EXPORT_SYMBOL_GPL(md_stop);
  5604. static int md_set_readonly(struct mddev *mddev, struct block_device *bdev)
  5605. {
  5606. int err = 0;
  5607. int did_freeze = 0;
  5608. if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
  5609. did_freeze = 1;
  5610. set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
  5611. md_wakeup_thread(mddev->thread);
  5612. }
  5613. if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
  5614. set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  5615. if (mddev->sync_thread)
  5616. /* Thread might be blocked waiting for metadata update
  5617. * which will now never happen */
  5618. wake_up_process(mddev->sync_thread->tsk);
  5619. if (mddev->external && test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags))
  5620. return -EBUSY;
  5621. mddev_unlock(mddev);
  5622. wait_event(resync_wait, !test_bit(MD_RECOVERY_RUNNING,
  5623. &mddev->recovery));
  5624. wait_event(mddev->sb_wait,
  5625. !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));
  5626. mddev_lock_nointr(mddev);
  5627. mutex_lock(&mddev->open_mutex);
  5628. if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
  5629. mddev->sync_thread ||
  5630. test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
  5631. pr_warn("md: %s still in use.\n",mdname(mddev));
  5632. if (did_freeze) {
  5633. clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
  5634. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  5635. md_wakeup_thread(mddev->thread);
  5636. }
  5637. err = -EBUSY;
  5638. goto out;
  5639. }
  5640. if (mddev->pers) {
  5641. __md_stop_writes(mddev);
  5642. err = -ENXIO;
  5643. if (mddev->ro==1)
  5644. goto out;
  5645. mddev->ro = 1;
  5646. set_disk_ro(mddev->gendisk, 1);
  5647. clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
  5648. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  5649. md_wakeup_thread(mddev->thread);
  5650. sysfs_notify_dirent_safe(mddev->sysfs_state);
  5651. err = 0;
  5652. }
  5653. out:
  5654. mutex_unlock(&mddev->open_mutex);
  5655. return err;
  5656. }
  5657. /* mode:
  5658. * 0 - completely stop and dis-assemble array
  5659. * 2 - stop but do not disassemble array
  5660. */
  5661. static int do_md_stop(struct mddev *mddev, int mode,
  5662. struct block_device *bdev)
  5663. {
  5664. struct gendisk *disk = mddev->gendisk;
  5665. struct md_rdev *rdev;
  5666. int did_freeze = 0;
  5667. if (!test_bit(MD_RECOVERY_FROZEN, &mddev->recovery)) {
  5668. did_freeze = 1;
  5669. set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
  5670. md_wakeup_thread(mddev->thread);
  5671. }
  5672. if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
  5673. set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  5674. if (mddev->sync_thread)
  5675. /* Thread might be blocked waiting for metadata update
  5676. * which will now never happen */
  5677. wake_up_process(mddev->sync_thread->tsk);
  5678. mddev_unlock(mddev);
  5679. wait_event(resync_wait, (mddev->sync_thread == NULL &&
  5680. !test_bit(MD_RECOVERY_RUNNING,
  5681. &mddev->recovery)));
  5682. mddev_lock_nointr(mddev);
  5683. mutex_lock(&mddev->open_mutex);
  5684. if ((mddev->pers && atomic_read(&mddev->openers) > !!bdev) ||
  5685. mddev->sysfs_active ||
  5686. mddev->sync_thread ||
  5687. test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
  5688. pr_warn("md: %s still in use.\n",mdname(mddev));
  5689. mutex_unlock(&mddev->open_mutex);
  5690. if (did_freeze) {
  5691. clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
  5692. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  5693. md_wakeup_thread(mddev->thread);
  5694. }
  5695. return -EBUSY;
  5696. }
  5697. if (mddev->pers) {
  5698. if (mddev->ro)
  5699. set_disk_ro(disk, 0);
  5700. __md_stop_writes(mddev);
  5701. __md_stop(mddev);
  5702. /* tell userspace to handle 'inactive' */
  5703. sysfs_notify_dirent_safe(mddev->sysfs_state);
  5704. rdev_for_each(rdev, mddev)
  5705. if (rdev->raid_disk >= 0)
  5706. sysfs_unlink_rdev(mddev, rdev);
  5707. set_capacity(disk, 0);
  5708. mutex_unlock(&mddev->open_mutex);
  5709. mddev->changed = 1;
  5710. revalidate_disk_size(disk, true);
  5711. if (mddev->ro)
  5712. mddev->ro = 0;
  5713. } else
  5714. mutex_unlock(&mddev->open_mutex);
  5715. /*
  5716. * Free resources if final stop
  5717. */
  5718. if (mode == 0) {
  5719. pr_info("md: %s stopped.\n", mdname(mddev));
  5720. if (mddev->bitmap_info.file) {
  5721. struct file *f = mddev->bitmap_info.file;
  5722. spin_lock(&mddev->lock);
  5723. mddev->bitmap_info.file = NULL;
  5724. spin_unlock(&mddev->lock);
  5725. fput(f);
  5726. }
  5727. mddev->bitmap_info.offset = 0;
  5728. export_array(mddev);
  5729. md_clean(mddev);
  5730. if (mddev->hold_active == UNTIL_STOP)
  5731. mddev->hold_active = 0;
  5732. }
  5733. md_new_event(mddev);
  5734. sysfs_notify_dirent_safe(mddev->sysfs_state);
  5735. return 0;
  5736. }
  5737. #ifndef MODULE
  5738. static void autorun_array(struct mddev *mddev)
  5739. {
  5740. struct md_rdev *rdev;
  5741. int err;
  5742. if (list_empty(&mddev->disks))
  5743. return;
  5744. pr_info("md: running: ");
  5745. rdev_for_each(rdev, mddev) {
  5746. char b[BDEVNAME_SIZE];
  5747. pr_cont("<%s>", bdevname(rdev->bdev,b));
  5748. }
  5749. pr_cont("\n");
  5750. err = do_md_run(mddev);
  5751. if (err) {
  5752. pr_warn("md: do_md_run() returned %d\n", err);
  5753. do_md_stop(mddev, 0, NULL);
  5754. }
  5755. }
  5756. /*
  5757. * lets try to run arrays based on all disks that have arrived
  5758. * until now. (those are in pending_raid_disks)
  5759. *
  5760. * the method: pick the first pending disk, collect all disks with
  5761. * the same UUID, remove all from the pending list and put them into
  5762. * the 'same_array' list. Then order this list based on superblock
  5763. * update time (freshest comes first), kick out 'old' disks and
  5764. * compare superblocks. If everything's fine then run it.
  5765. *
  5766. * If "unit" is allocated, then bump its reference count
  5767. */
  5768. static void autorun_devices(int part)
  5769. {
  5770. struct md_rdev *rdev0, *rdev, *tmp;
  5771. struct mddev *mddev;
  5772. char b[BDEVNAME_SIZE];
  5773. pr_info("md: autorun ...\n");
  5774. while (!list_empty(&pending_raid_disks)) {
  5775. int unit;
  5776. dev_t dev;
  5777. LIST_HEAD(candidates);
  5778. rdev0 = list_entry(pending_raid_disks.next,
  5779. struct md_rdev, same_set);
  5780. pr_debug("md: considering %s ...\n", bdevname(rdev0->bdev,b));
  5781. INIT_LIST_HEAD(&candidates);
  5782. rdev_for_each_list(rdev, tmp, &pending_raid_disks)
  5783. if (super_90_load(rdev, rdev0, 0) >= 0) {
  5784. pr_debug("md: adding %s ...\n",
  5785. bdevname(rdev->bdev,b));
  5786. list_move(&rdev->same_set, &candidates);
  5787. }
  5788. /*
  5789. * now we have a set of devices, with all of them having
  5790. * mostly sane superblocks. It's time to allocate the
  5791. * mddev.
  5792. */
  5793. if (part) {
  5794. dev = MKDEV(mdp_major,
  5795. rdev0->preferred_minor << MdpMinorShift);
  5796. unit = MINOR(dev) >> MdpMinorShift;
  5797. } else {
  5798. dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
  5799. unit = MINOR(dev);
  5800. }
  5801. if (rdev0->preferred_minor != unit) {
  5802. pr_warn("md: unit number in %s is bad: %d\n",
  5803. bdevname(rdev0->bdev, b), rdev0->preferred_minor);
  5804. break;
  5805. }
  5806. md_probe(dev, NULL, NULL);
  5807. mddev = mddev_find(dev);
  5808. if (!mddev)
  5809. break;
  5810. if (mddev_lock(mddev))
  5811. pr_warn("md: %s locked, cannot run\n", mdname(mddev));
  5812. else if (mddev->raid_disks || mddev->major_version
  5813. || !list_empty(&mddev->disks)) {
  5814. pr_warn("md: %s already running, cannot run %s\n",
  5815. mdname(mddev), bdevname(rdev0->bdev,b));
  5816. mddev_unlock(mddev);
  5817. } else {
  5818. pr_debug("md: created %s\n", mdname(mddev));
  5819. mddev->persistent = 1;
  5820. rdev_for_each_list(rdev, tmp, &candidates) {
  5821. list_del_init(&rdev->same_set);
  5822. if (bind_rdev_to_array(rdev, mddev))
  5823. export_rdev(rdev);
  5824. }
  5825. autorun_array(mddev);
  5826. mddev_unlock(mddev);
  5827. }
  5828. /* on success, candidates will be empty, on error
  5829. * it won't...
  5830. */
  5831. rdev_for_each_list(rdev, tmp, &candidates) {
  5832. list_del_init(&rdev->same_set);
  5833. export_rdev(rdev);
  5834. }
  5835. mddev_put(mddev);
  5836. }
  5837. pr_info("md: ... autorun DONE.\n");
  5838. }
  5839. #endif /* !MODULE */
  5840. static int get_version(void __user *arg)
  5841. {
  5842. mdu_version_t ver;
  5843. ver.major = MD_MAJOR_VERSION;
  5844. ver.minor = MD_MINOR_VERSION;
  5845. ver.patchlevel = MD_PATCHLEVEL_VERSION;
  5846. if (copy_to_user(arg, &ver, sizeof(ver)))
  5847. return -EFAULT;
  5848. return 0;
  5849. }
  5850. static int get_array_info(struct mddev *mddev, void __user *arg)
  5851. {
  5852. mdu_array_info_t info;
  5853. int nr,working,insync,failed,spare;
  5854. struct md_rdev *rdev;
  5855. nr = working = insync = failed = spare = 0;
  5856. rcu_read_lock();
  5857. rdev_for_each_rcu(rdev, mddev) {
  5858. nr++;
  5859. if (test_bit(Faulty, &rdev->flags))
  5860. failed++;
  5861. else {
  5862. working++;
  5863. if (test_bit(In_sync, &rdev->flags))
  5864. insync++;
  5865. else if (test_bit(Journal, &rdev->flags))
  5866. /* TODO: add journal count to md_u.h */
  5867. ;
  5868. else
  5869. spare++;
  5870. }
  5871. }
  5872. rcu_read_unlock();
  5873. info.major_version = mddev->major_version;
  5874. info.minor_version = mddev->minor_version;
  5875. info.patch_version = MD_PATCHLEVEL_VERSION;
  5876. info.ctime = clamp_t(time64_t, mddev->ctime, 0, U32_MAX);
  5877. info.level = mddev->level;
  5878. info.size = mddev->dev_sectors / 2;
  5879. if (info.size != mddev->dev_sectors / 2) /* overflow */
  5880. info.size = -1;
  5881. info.nr_disks = nr;
  5882. info.raid_disks = mddev->raid_disks;
  5883. info.md_minor = mddev->md_minor;
  5884. info.not_persistent= !mddev->persistent;
  5885. info.utime = clamp_t(time64_t, mddev->utime, 0, U32_MAX);
  5886. info.state = 0;
  5887. if (mddev->in_sync)
  5888. info.state = (1<<MD_SB_CLEAN);
  5889. if (mddev->bitmap && mddev->bitmap_info.offset)
  5890. info.state |= (1<<MD_SB_BITMAP_PRESENT);
  5891. if (mddev_is_clustered(mddev))
  5892. info.state |= (1<<MD_SB_CLUSTERED);
  5893. info.active_disks = insync;
  5894. info.working_disks = working;
  5895. info.failed_disks = failed;
  5896. info.spare_disks = spare;
  5897. info.layout = mddev->layout;
  5898. info.chunk_size = mddev->chunk_sectors << 9;
  5899. if (copy_to_user(arg, &info, sizeof(info)))
  5900. return -EFAULT;
  5901. return 0;
  5902. }
  5903. static int get_bitmap_file(struct mddev *mddev, void __user * arg)
  5904. {
  5905. mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
  5906. char *ptr;
  5907. int err;
  5908. file = kzalloc(sizeof(*file), GFP_NOIO);
  5909. if (!file)
  5910. return -ENOMEM;
  5911. err = 0;
  5912. spin_lock(&mddev->lock);
  5913. /* bitmap enabled */
  5914. if (mddev->bitmap_info.file) {
  5915. ptr = file_path(mddev->bitmap_info.file, file->pathname,
  5916. sizeof(file->pathname));
  5917. if (IS_ERR(ptr))
  5918. err = PTR_ERR(ptr);
  5919. else
  5920. memmove(file->pathname, ptr,
  5921. sizeof(file->pathname)-(ptr-file->pathname));
  5922. }
  5923. spin_unlock(&mddev->lock);
  5924. if (err == 0 &&
  5925. copy_to_user(arg, file, sizeof(*file)))
  5926. err = -EFAULT;
  5927. kfree(file);
  5928. return err;
  5929. }
  5930. static int get_disk_info(struct mddev *mddev, void __user * arg)
  5931. {
  5932. mdu_disk_info_t info;
  5933. struct md_rdev *rdev;
  5934. if (copy_from_user(&info, arg, sizeof(info)))
  5935. return -EFAULT;
  5936. rcu_read_lock();
  5937. rdev = md_find_rdev_nr_rcu(mddev, info.number);
  5938. if (rdev) {
  5939. info.major = MAJOR(rdev->bdev->bd_dev);
  5940. info.minor = MINOR(rdev->bdev->bd_dev);
  5941. info.raid_disk = rdev->raid_disk;
  5942. info.state = 0;
  5943. if (test_bit(Faulty, &rdev->flags))
  5944. info.state |= (1<<MD_DISK_FAULTY);
  5945. else if (test_bit(In_sync, &rdev->flags)) {
  5946. info.state |= (1<<MD_DISK_ACTIVE);
  5947. info.state |= (1<<MD_DISK_SYNC);
  5948. }
  5949. if (test_bit(Journal, &rdev->flags))
  5950. info.state |= (1<<MD_DISK_JOURNAL);
  5951. if (test_bit(WriteMostly, &rdev->flags))
  5952. info.state |= (1<<MD_DISK_WRITEMOSTLY);
  5953. if (test_bit(FailFast, &rdev->flags))
  5954. info.state |= (1<<MD_DISK_FAILFAST);
  5955. } else {
  5956. info.major = info.minor = 0;
  5957. info.raid_disk = -1;
  5958. info.state = (1<<MD_DISK_REMOVED);
  5959. }
  5960. rcu_read_unlock();
  5961. if (copy_to_user(arg, &info, sizeof(info)))
  5962. return -EFAULT;
  5963. return 0;
  5964. }
  5965. int md_add_new_disk(struct mddev *mddev, struct mdu_disk_info_s *info)
  5966. {
  5967. char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
  5968. struct md_rdev *rdev;
  5969. dev_t dev = MKDEV(info->major,info->minor);
  5970. if (mddev_is_clustered(mddev) &&
  5971. !(info->state & ((1 << MD_DISK_CLUSTER_ADD) | (1 << MD_DISK_CANDIDATE)))) {
  5972. pr_warn("%s: Cannot add to clustered mddev.\n",
  5973. mdname(mddev));
  5974. return -EINVAL;
  5975. }
  5976. if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
  5977. return -EOVERFLOW;
  5978. if (!mddev->raid_disks) {
  5979. int err;
  5980. /* expecting a device which has a superblock */
  5981. rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
  5982. if (IS_ERR(rdev)) {
  5983. pr_warn("md: md_import_device returned %ld\n",
  5984. PTR_ERR(rdev));
  5985. return PTR_ERR(rdev);
  5986. }
  5987. if (!list_empty(&mddev->disks)) {
  5988. struct md_rdev *rdev0
  5989. = list_entry(mddev->disks.next,
  5990. struct md_rdev, same_set);
  5991. err = super_types[mddev->major_version]
  5992. .load_super(rdev, rdev0, mddev->minor_version);
  5993. if (err < 0) {
  5994. pr_warn("md: %s has different UUID to %s\n",
  5995. bdevname(rdev->bdev,b),
  5996. bdevname(rdev0->bdev,b2));
  5997. export_rdev(rdev);
  5998. return -EINVAL;
  5999. }
  6000. }
  6001. err = bind_rdev_to_array(rdev, mddev);
  6002. if (err)
  6003. export_rdev(rdev);
  6004. return err;
  6005. }
  6006. /*
  6007. * md_add_new_disk can be used once the array is assembled
  6008. * to add "hot spares". They must already have a superblock
  6009. * written
  6010. */
  6011. if (mddev->pers) {
  6012. int err;
  6013. if (!mddev->pers->hot_add_disk) {
  6014. pr_warn("%s: personality does not support diskops!\n",
  6015. mdname(mddev));
  6016. return -EINVAL;
  6017. }
  6018. if (mddev->persistent)
  6019. rdev = md_import_device(dev, mddev->major_version,
  6020. mddev->minor_version);
  6021. else
  6022. rdev = md_import_device(dev, -1, -1);
  6023. if (IS_ERR(rdev)) {
  6024. pr_warn("md: md_import_device returned %ld\n",
  6025. PTR_ERR(rdev));
  6026. return PTR_ERR(rdev);
  6027. }
  6028. /* set saved_raid_disk if appropriate */
  6029. if (!mddev->persistent) {
  6030. if (info->state & (1<<MD_DISK_SYNC) &&
  6031. info->raid_disk < mddev->raid_disks) {
  6032. rdev->raid_disk = info->raid_disk;
  6033. set_bit(In_sync, &rdev->flags);
  6034. clear_bit(Bitmap_sync, &rdev->flags);
  6035. } else
  6036. rdev->raid_disk = -1;
  6037. rdev->saved_raid_disk = rdev->raid_disk;
  6038. } else
  6039. super_types[mddev->major_version].
  6040. validate_super(mddev, rdev);
  6041. if ((info->state & (1<<MD_DISK_SYNC)) &&
  6042. rdev->raid_disk != info->raid_disk) {
  6043. /* This was a hot-add request, but events doesn't
  6044. * match, so reject it.
  6045. */
  6046. export_rdev(rdev);
  6047. return -EINVAL;
  6048. }
  6049. clear_bit(In_sync, &rdev->flags); /* just to be sure */
  6050. if (info->state & (1<<MD_DISK_WRITEMOSTLY))
  6051. set_bit(WriteMostly, &rdev->flags);
  6052. else
  6053. clear_bit(WriteMostly, &rdev->flags);
  6054. if (info->state & (1<<MD_DISK_FAILFAST))
  6055. set_bit(FailFast, &rdev->flags);
  6056. else
  6057. clear_bit(FailFast, &rdev->flags);
  6058. if (info->state & (1<<MD_DISK_JOURNAL)) {
  6059. struct md_rdev *rdev2;
  6060. bool has_journal = false;
  6061. /* make sure no existing journal disk */
  6062. rdev_for_each(rdev2, mddev) {
  6063. if (test_bit(Journal, &rdev2->flags)) {
  6064. has_journal = true;
  6065. break;
  6066. }
  6067. }
  6068. if (has_journal || mddev->bitmap) {
  6069. export_rdev(rdev);
  6070. return -EBUSY;
  6071. }
  6072. set_bit(Journal, &rdev->flags);
  6073. }
  6074. /*
  6075. * check whether the device shows up in other nodes
  6076. */
  6077. if (mddev_is_clustered(mddev)) {
  6078. if (info->state & (1 << MD_DISK_CANDIDATE))
  6079. set_bit(Candidate, &rdev->flags);
  6080. else if (info->state & (1 << MD_DISK_CLUSTER_ADD)) {
  6081. /* --add initiated by this node */
  6082. err = md_cluster_ops->add_new_disk(mddev, rdev);
  6083. if (err) {
  6084. export_rdev(rdev);
  6085. return err;
  6086. }
  6087. }
  6088. }
  6089. rdev->raid_disk = -1;
  6090. err = bind_rdev_to_array(rdev, mddev);
  6091. if (err)
  6092. export_rdev(rdev);
  6093. if (mddev_is_clustered(mddev)) {
  6094. if (info->state & (1 << MD_DISK_CANDIDATE)) {
  6095. if (!err) {
  6096. err = md_cluster_ops->new_disk_ack(mddev,
  6097. err == 0);
  6098. if (err)
  6099. md_kick_rdev_from_array(rdev);
  6100. }
  6101. } else {
  6102. if (err)
  6103. md_cluster_ops->add_new_disk_cancel(mddev);
  6104. else
  6105. err = add_bound_rdev(rdev);
  6106. }
  6107. } else if (!err)
  6108. err = add_bound_rdev(rdev);
  6109. return err;
  6110. }
  6111. /* otherwise, md_add_new_disk is only allowed
  6112. * for major_version==0 superblocks
  6113. */
  6114. if (mddev->major_version != 0) {
  6115. pr_warn("%s: ADD_NEW_DISK not supported\n", mdname(mddev));
  6116. return -EINVAL;
  6117. }
  6118. if (!(info->state & (1<<MD_DISK_FAULTY))) {
  6119. int err;
  6120. rdev = md_import_device(dev, -1, 0);
  6121. if (IS_ERR(rdev)) {
  6122. pr_warn("md: error, md_import_device() returned %ld\n",
  6123. PTR_ERR(rdev));
  6124. return PTR_ERR(rdev);
  6125. }
  6126. rdev->desc_nr = info->number;
  6127. if (info->raid_disk < mddev->raid_disks)
  6128. rdev->raid_disk = info->raid_disk;
  6129. else
  6130. rdev->raid_disk = -1;
  6131. if (rdev->raid_disk < mddev->raid_disks)
  6132. if (info->state & (1<<MD_DISK_SYNC))
  6133. set_bit(In_sync, &rdev->flags);
  6134. if (info->state & (1<<MD_DISK_WRITEMOSTLY))
  6135. set_bit(WriteMostly, &rdev->flags);
  6136. if (info->state & (1<<MD_DISK_FAILFAST))
  6137. set_bit(FailFast, &rdev->flags);
  6138. if (!mddev->persistent) {
  6139. pr_debug("md: nonpersistent superblock ...\n");
  6140. rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
  6141. } else
  6142. rdev->sb_start = calc_dev_sboffset(rdev);
  6143. rdev->sectors = rdev->sb_start;
  6144. err = bind_rdev_to_array(rdev, mddev);
  6145. if (err) {
  6146. export_rdev(rdev);
  6147. return err;
  6148. }
  6149. }
  6150. return 0;
  6151. }
  6152. static int hot_remove_disk(struct mddev *mddev, dev_t dev)
  6153. {
  6154. char b[BDEVNAME_SIZE];
  6155. struct md_rdev *rdev;
  6156. if (!mddev->pers)
  6157. return -ENODEV;
  6158. rdev = find_rdev(mddev, dev);
  6159. if (!rdev)
  6160. return -ENXIO;
  6161. if (rdev->raid_disk < 0)
  6162. goto kick_rdev;
  6163. clear_bit(Blocked, &rdev->flags);
  6164. remove_and_add_spares(mddev, rdev);
  6165. if (rdev->raid_disk >= 0)
  6166. goto busy;
  6167. kick_rdev:
  6168. if (mddev_is_clustered(mddev)) {
  6169. if (md_cluster_ops->remove_disk(mddev, rdev))
  6170. goto busy;
  6171. }
  6172. md_kick_rdev_from_array(rdev);
  6173. set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
  6174. if (mddev->thread)
  6175. md_wakeup_thread(mddev->thread);
  6176. else
  6177. md_update_sb(mddev, 1);
  6178. md_new_event(mddev);
  6179. return 0;
  6180. busy:
  6181. pr_debug("md: cannot remove active disk %s from %s ...\n",
  6182. bdevname(rdev->bdev,b), mdname(mddev));
  6183. return -EBUSY;
  6184. }
  6185. static int hot_add_disk(struct mddev *mddev, dev_t dev)
  6186. {
  6187. char b[BDEVNAME_SIZE];
  6188. int err;
  6189. struct md_rdev *rdev;
  6190. if (!mddev->pers)
  6191. return -ENODEV;
  6192. if (mddev->major_version != 0) {
  6193. pr_warn("%s: HOT_ADD may only be used with version-0 superblocks.\n",
  6194. mdname(mddev));
  6195. return -EINVAL;
  6196. }
  6197. if (!mddev->pers->hot_add_disk) {
  6198. pr_warn("%s: personality does not support diskops!\n",
  6199. mdname(mddev));
  6200. return -EINVAL;
  6201. }
  6202. rdev = md_import_device(dev, -1, 0);
  6203. if (IS_ERR(rdev)) {
  6204. pr_warn("md: error, md_import_device() returned %ld\n",
  6205. PTR_ERR(rdev));
  6206. return -EINVAL;
  6207. }
  6208. if (mddev->persistent)
  6209. rdev->sb_start = calc_dev_sboffset(rdev);
  6210. else
  6211. rdev->sb_start = i_size_read(rdev->bdev->bd_inode) / 512;
  6212. rdev->sectors = rdev->sb_start;
  6213. if (test_bit(Faulty, &rdev->flags)) {
  6214. pr_warn("md: can not hot-add faulty %s disk to %s!\n",
  6215. bdevname(rdev->bdev,b), mdname(mddev));
  6216. err = -EINVAL;
  6217. goto abort_export;
  6218. }
  6219. clear_bit(In_sync, &rdev->flags);
  6220. rdev->desc_nr = -1;
  6221. rdev->saved_raid_disk = -1;
  6222. err = bind_rdev_to_array(rdev, mddev);
  6223. if (err)
  6224. goto abort_export;
  6225. /*
  6226. * The rest should better be atomic, we can have disk failures
  6227. * noticed in interrupt contexts ...
  6228. */
  6229. rdev->raid_disk = -1;
  6230. set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
  6231. if (!mddev->thread)
  6232. md_update_sb(mddev, 1);
  6233. /*
  6234. * Kick recovery, maybe this spare has to be added to the
  6235. * array immediately.
  6236. */
  6237. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  6238. md_wakeup_thread(mddev->thread);
  6239. md_new_event(mddev);
  6240. return 0;
  6241. abort_export:
  6242. export_rdev(rdev);
  6243. return err;
  6244. }
  6245. static int set_bitmap_file(struct mddev *mddev, int fd)
  6246. {
  6247. int err = 0;
  6248. if (mddev->pers) {
  6249. if (!mddev->pers->quiesce || !mddev->thread)
  6250. return -EBUSY;
  6251. if (mddev->recovery || mddev->sync_thread)
  6252. return -EBUSY;
  6253. /* we should be able to change the bitmap.. */
  6254. }
  6255. if (fd >= 0) {
  6256. struct inode *inode;
  6257. struct file *f;
  6258. if (mddev->bitmap || mddev->bitmap_info.file)
  6259. return -EEXIST; /* cannot add when bitmap is present */
  6260. f = fget(fd);
  6261. if (f == NULL) {
  6262. pr_warn("%s: error: failed to get bitmap file\n",
  6263. mdname(mddev));
  6264. return -EBADF;
  6265. }
  6266. inode = f->f_mapping->host;
  6267. if (!S_ISREG(inode->i_mode)) {
  6268. pr_warn("%s: error: bitmap file must be a regular file\n",
  6269. mdname(mddev));
  6270. err = -EBADF;
  6271. } else if (!(f->f_mode & FMODE_WRITE)) {
  6272. pr_warn("%s: error: bitmap file must open for write\n",
  6273. mdname(mddev));
  6274. err = -EBADF;
  6275. } else if (atomic_read(&inode->i_writecount) != 1) {
  6276. pr_warn("%s: error: bitmap file is already in use\n",
  6277. mdname(mddev));
  6278. err = -EBUSY;
  6279. }
  6280. if (err) {
  6281. fput(f);
  6282. return err;
  6283. }
  6284. mddev->bitmap_info.file = f;
  6285. mddev->bitmap_info.offset = 0; /* file overrides offset */
  6286. } else if (mddev->bitmap == NULL)
  6287. return -ENOENT; /* cannot remove what isn't there */
  6288. err = 0;
  6289. if (mddev->pers) {
  6290. if (fd >= 0) {
  6291. struct bitmap *bitmap;
  6292. bitmap = md_bitmap_create(mddev, -1);
  6293. mddev_suspend(mddev);
  6294. if (!IS_ERR(bitmap)) {
  6295. mddev->bitmap = bitmap;
  6296. err = md_bitmap_load(mddev);
  6297. } else
  6298. err = PTR_ERR(bitmap);
  6299. if (err) {
  6300. md_bitmap_destroy(mddev);
  6301. fd = -1;
  6302. }
  6303. mddev_resume(mddev);
  6304. } else if (fd < 0) {
  6305. mddev_suspend(mddev);
  6306. md_bitmap_destroy(mddev);
  6307. mddev_resume(mddev);
  6308. }
  6309. }
  6310. if (fd < 0) {
  6311. struct file *f = mddev->bitmap_info.file;
  6312. if (f) {
  6313. spin_lock(&mddev->lock);
  6314. mddev->bitmap_info.file = NULL;
  6315. spin_unlock(&mddev->lock);
  6316. fput(f);
  6317. }
  6318. }
  6319. return err;
  6320. }
  6321. /*
  6322. * md_set_array_info is used two different ways
  6323. * The original usage is when creating a new array.
  6324. * In this usage, raid_disks is > 0 and it together with
  6325. * level, size, not_persistent,layout,chunksize determine the
  6326. * shape of the array.
  6327. * This will always create an array with a type-0.90.0 superblock.
  6328. * The newer usage is when assembling an array.
  6329. * In this case raid_disks will be 0, and the major_version field is
  6330. * use to determine which style super-blocks are to be found on the devices.
  6331. * The minor and patch _version numbers are also kept incase the
  6332. * super_block handler wishes to interpret them.
  6333. */
  6334. int md_set_array_info(struct mddev *mddev, struct mdu_array_info_s *info)
  6335. {
  6336. if (info->raid_disks == 0) {
  6337. /* just setting version number for superblock loading */
  6338. if (info->major_version < 0 ||
  6339. info->major_version >= ARRAY_SIZE(super_types) ||
  6340. super_types[info->major_version].name == NULL) {
  6341. /* maybe try to auto-load a module? */
  6342. pr_warn("md: superblock version %d not known\n",
  6343. info->major_version);
  6344. return -EINVAL;
  6345. }
  6346. mddev->major_version = info->major_version;
  6347. mddev->minor_version = info->minor_version;
  6348. mddev->patch_version = info->patch_version;
  6349. mddev->persistent = !info->not_persistent;
  6350. /* ensure mddev_put doesn't delete this now that there
  6351. * is some minimal configuration.
  6352. */
  6353. mddev->ctime = ktime_get_real_seconds();
  6354. return 0;
  6355. }
  6356. mddev->major_version = MD_MAJOR_VERSION;
  6357. mddev->minor_version = MD_MINOR_VERSION;
  6358. mddev->patch_version = MD_PATCHLEVEL_VERSION;
  6359. mddev->ctime = ktime_get_real_seconds();
  6360. mddev->level = info->level;
  6361. mddev->clevel[0] = 0;
  6362. mddev->dev_sectors = 2 * (sector_t)info->size;
  6363. mddev->raid_disks = info->raid_disks;
  6364. /* don't set md_minor, it is determined by which /dev/md* was
  6365. * openned
  6366. */
  6367. if (info->state & (1<<MD_SB_CLEAN))
  6368. mddev->recovery_cp = MaxSector;
  6369. else
  6370. mddev->recovery_cp = 0;
  6371. mddev->persistent = ! info->not_persistent;
  6372. mddev->external = 0;
  6373. mddev->layout = info->layout;
  6374. if (mddev->level == 0)
  6375. /* Cannot trust RAID0 layout info here */
  6376. mddev->layout = -1;
  6377. mddev->chunk_sectors = info->chunk_size >> 9;
  6378. if (mddev->persistent) {
  6379. mddev->max_disks = MD_SB_DISKS;
  6380. mddev->flags = 0;
  6381. mddev->sb_flags = 0;
  6382. }
  6383. set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
  6384. mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
  6385. mddev->bitmap_info.default_space = 64*2 - (MD_SB_BYTES >> 9);
  6386. mddev->bitmap_info.offset = 0;
  6387. mddev->reshape_position = MaxSector;
  6388. /*
  6389. * Generate a 128 bit UUID
  6390. */
  6391. get_random_bytes(mddev->uuid, 16);
  6392. mddev->new_level = mddev->level;
  6393. mddev->new_chunk_sectors = mddev->chunk_sectors;
  6394. mddev->new_layout = mddev->layout;
  6395. mddev->delta_disks = 0;
  6396. mddev->reshape_backwards = 0;
  6397. return 0;
  6398. }
  6399. void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors)
  6400. {
  6401. lockdep_assert_held(&mddev->reconfig_mutex);
  6402. if (mddev->external_size)
  6403. return;
  6404. mddev->array_sectors = array_sectors;
  6405. }
  6406. EXPORT_SYMBOL(md_set_array_sectors);
  6407. static int update_size(struct mddev *mddev, sector_t num_sectors)
  6408. {
  6409. struct md_rdev *rdev;
  6410. int rv;
  6411. int fit = (num_sectors == 0);
  6412. sector_t old_dev_sectors = mddev->dev_sectors;
  6413. if (mddev->pers->resize == NULL)
  6414. return -EINVAL;
  6415. /* The "num_sectors" is the number of sectors of each device that
  6416. * is used. This can only make sense for arrays with redundancy.
  6417. * linear and raid0 always use whatever space is available. We can only
  6418. * consider changing this number if no resync or reconstruction is
  6419. * happening, and if the new size is acceptable. It must fit before the
  6420. * sb_start or, if that is <data_offset, it must fit before the size
  6421. * of each device. If num_sectors is zero, we find the largest size
  6422. * that fits.
  6423. */
  6424. if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
  6425. mddev->sync_thread)
  6426. return -EBUSY;
  6427. if (mddev->ro)
  6428. return -EROFS;
  6429. rdev_for_each(rdev, mddev) {
  6430. sector_t avail = rdev->sectors;
  6431. if (fit && (num_sectors == 0 || num_sectors > avail))
  6432. num_sectors = avail;
  6433. if (avail < num_sectors)
  6434. return -ENOSPC;
  6435. }
  6436. rv = mddev->pers->resize(mddev, num_sectors);
  6437. if (!rv) {
  6438. if (mddev_is_clustered(mddev))
  6439. md_cluster_ops->update_size(mddev, old_dev_sectors);
  6440. else if (mddev->queue) {
  6441. set_capacity(mddev->gendisk, mddev->array_sectors);
  6442. revalidate_disk_size(mddev->gendisk, true);
  6443. }
  6444. }
  6445. return rv;
  6446. }
  6447. static int update_raid_disks(struct mddev *mddev, int raid_disks)
  6448. {
  6449. int rv;
  6450. struct md_rdev *rdev;
  6451. /* change the number of raid disks */
  6452. if (mddev->pers->check_reshape == NULL)
  6453. return -EINVAL;
  6454. if (mddev->ro)
  6455. return -EROFS;
  6456. if (raid_disks <= 0 ||
  6457. (mddev->max_disks && raid_disks >= mddev->max_disks))
  6458. return -EINVAL;
  6459. if (mddev->sync_thread ||
  6460. test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
  6461. test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) ||
  6462. mddev->reshape_position != MaxSector)
  6463. return -EBUSY;
  6464. rdev_for_each(rdev, mddev) {
  6465. if (mddev->raid_disks < raid_disks &&
  6466. rdev->data_offset < rdev->new_data_offset)
  6467. return -EINVAL;
  6468. if (mddev->raid_disks > raid_disks &&
  6469. rdev->data_offset > rdev->new_data_offset)
  6470. return -EINVAL;
  6471. }
  6472. mddev->delta_disks = raid_disks - mddev->raid_disks;
  6473. if (mddev->delta_disks < 0)
  6474. mddev->reshape_backwards = 1;
  6475. else if (mddev->delta_disks > 0)
  6476. mddev->reshape_backwards = 0;
  6477. rv = mddev->pers->check_reshape(mddev);
  6478. if (rv < 0) {
  6479. mddev->delta_disks = 0;
  6480. mddev->reshape_backwards = 0;
  6481. }
  6482. return rv;
  6483. }
  6484. /*
  6485. * update_array_info is used to change the configuration of an
  6486. * on-line array.
  6487. * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
  6488. * fields in the info are checked against the array.
  6489. * Any differences that cannot be handled will cause an error.
  6490. * Normally, only one change can be managed at a time.
  6491. */
  6492. static int update_array_info(struct mddev *mddev, mdu_array_info_t *info)
  6493. {
  6494. int rv = 0;
  6495. int cnt = 0;
  6496. int state = 0;
  6497. /* calculate expected state,ignoring low bits */
  6498. if (mddev->bitmap && mddev->bitmap_info.offset)
  6499. state |= (1 << MD_SB_BITMAP_PRESENT);
  6500. if (mddev->major_version != info->major_version ||
  6501. mddev->minor_version != info->minor_version ||
  6502. /* mddev->patch_version != info->patch_version || */
  6503. mddev->ctime != info->ctime ||
  6504. mddev->level != info->level ||
  6505. /* mddev->layout != info->layout || */
  6506. mddev->persistent != !info->not_persistent ||
  6507. mddev->chunk_sectors != info->chunk_size >> 9 ||
  6508. /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
  6509. ((state^info->state) & 0xfffffe00)
  6510. )
  6511. return -EINVAL;
  6512. /* Check there is only one change */
  6513. if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
  6514. cnt++;
  6515. if (mddev->raid_disks != info->raid_disks)
  6516. cnt++;
  6517. if (mddev->layout != info->layout)
  6518. cnt++;
  6519. if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT))
  6520. cnt++;
  6521. if (cnt == 0)
  6522. return 0;
  6523. if (cnt > 1)
  6524. return -EINVAL;
  6525. if (mddev->layout != info->layout) {
  6526. /* Change layout
  6527. * we don't need to do anything at the md level, the
  6528. * personality will take care of it all.
  6529. */
  6530. if (mddev->pers->check_reshape == NULL)
  6531. return -EINVAL;
  6532. else {
  6533. mddev->new_layout = info->layout;
  6534. rv = mddev->pers->check_reshape(mddev);
  6535. if (rv)
  6536. mddev->new_layout = mddev->layout;
  6537. return rv;
  6538. }
  6539. }
  6540. if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
  6541. rv = update_size(mddev, (sector_t)info->size * 2);
  6542. if (mddev->raid_disks != info->raid_disks)
  6543. rv = update_raid_disks(mddev, info->raid_disks);
  6544. if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) {
  6545. if (mddev->pers->quiesce == NULL || mddev->thread == NULL) {
  6546. rv = -EINVAL;
  6547. goto err;
  6548. }
  6549. if (mddev->recovery || mddev->sync_thread) {
  6550. rv = -EBUSY;
  6551. goto err;
  6552. }
  6553. if (info->state & (1<<MD_SB_BITMAP_PRESENT)) {
  6554. struct bitmap *bitmap;
  6555. /* add the bitmap */
  6556. if (mddev->bitmap) {
  6557. rv = -EEXIST;
  6558. goto err;
  6559. }
  6560. if (mddev->bitmap_info.default_offset == 0) {
  6561. rv = -EINVAL;
  6562. goto err;
  6563. }
  6564. mddev->bitmap_info.offset =
  6565. mddev->bitmap_info.default_offset;
  6566. mddev->bitmap_info.space =
  6567. mddev->bitmap_info.default_space;
  6568. bitmap = md_bitmap_create(mddev, -1);
  6569. mddev_suspend(mddev);
  6570. if (!IS_ERR(bitmap)) {
  6571. mddev->bitmap = bitmap;
  6572. rv = md_bitmap_load(mddev);
  6573. } else
  6574. rv = PTR_ERR(bitmap);
  6575. if (rv)
  6576. md_bitmap_destroy(mddev);
  6577. mddev_resume(mddev);
  6578. } else {
  6579. /* remove the bitmap */
  6580. if (!mddev->bitmap) {
  6581. rv = -ENOENT;
  6582. goto err;
  6583. }
  6584. if (mddev->bitmap->storage.file) {
  6585. rv = -EINVAL;
  6586. goto err;
  6587. }
  6588. if (mddev->bitmap_info.nodes) {
  6589. /* hold PW on all the bitmap lock */
  6590. if (md_cluster_ops->lock_all_bitmaps(mddev) <= 0) {
  6591. pr_warn("md: can't change bitmap to none since the array is in use by more than one node\n");
  6592. rv = -EPERM;
  6593. md_cluster_ops->unlock_all_bitmaps(mddev);
  6594. goto err;
  6595. }
  6596. mddev->bitmap_info.nodes = 0;
  6597. md_cluster_ops->leave(mddev);
  6598. module_put(md_cluster_mod);
  6599. mddev->safemode_delay = DEFAULT_SAFEMODE_DELAY;
  6600. }
  6601. mddev_suspend(mddev);
  6602. md_bitmap_destroy(mddev);
  6603. mddev_resume(mddev);
  6604. mddev->bitmap_info.offset = 0;
  6605. }
  6606. }
  6607. md_update_sb(mddev, 1);
  6608. return rv;
  6609. err:
  6610. return rv;
  6611. }
  6612. static int set_disk_faulty(struct mddev *mddev, dev_t dev)
  6613. {
  6614. struct md_rdev *rdev;
  6615. int err = 0;
  6616. if (mddev->pers == NULL)
  6617. return -ENODEV;
  6618. rcu_read_lock();
  6619. rdev = md_find_rdev_rcu(mddev, dev);
  6620. if (!rdev)
  6621. err = -ENODEV;
  6622. else {
  6623. md_error(mddev, rdev);
  6624. if (!test_bit(Faulty, &rdev->flags))
  6625. err = -EBUSY;
  6626. }
  6627. rcu_read_unlock();
  6628. return err;
  6629. }
  6630. /*
  6631. * We have a problem here : there is no easy way to give a CHS
  6632. * virtual geometry. We currently pretend that we have a 2 heads
  6633. * 4 sectors (with a BIG number of cylinders...). This drives
  6634. * dosfs just mad... ;-)
  6635. */
  6636. static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
  6637. {
  6638. struct mddev *mddev = bdev->bd_disk->private_data;
  6639. geo->heads = 2;
  6640. geo->sectors = 4;
  6641. geo->cylinders = mddev->array_sectors / 8;
  6642. return 0;
  6643. }
  6644. static inline bool md_ioctl_valid(unsigned int cmd)
  6645. {
  6646. switch (cmd) {
  6647. case ADD_NEW_DISK:
  6648. case BLKROSET:
  6649. case GET_ARRAY_INFO:
  6650. case GET_BITMAP_FILE:
  6651. case GET_DISK_INFO:
  6652. case HOT_ADD_DISK:
  6653. case HOT_REMOVE_DISK:
  6654. case RAID_VERSION:
  6655. case RESTART_ARRAY_RW:
  6656. case RUN_ARRAY:
  6657. case SET_ARRAY_INFO:
  6658. case SET_BITMAP_FILE:
  6659. case SET_DISK_FAULTY:
  6660. case STOP_ARRAY:
  6661. case STOP_ARRAY_RO:
  6662. case CLUSTERED_DISK_NACK:
  6663. return true;
  6664. default:
  6665. return false;
  6666. }
  6667. }
  6668. static int md_ioctl(struct block_device *bdev, fmode_t mode,
  6669. unsigned int cmd, unsigned long arg)
  6670. {
  6671. int err = 0;
  6672. void __user *argp = (void __user *)arg;
  6673. struct mddev *mddev = NULL;
  6674. int ro;
  6675. bool did_set_md_closing = false;
  6676. if (!md_ioctl_valid(cmd))
  6677. return -ENOTTY;
  6678. switch (cmd) {
  6679. case RAID_VERSION:
  6680. case GET_ARRAY_INFO:
  6681. case GET_DISK_INFO:
  6682. break;
  6683. default:
  6684. if (!capable(CAP_SYS_ADMIN))
  6685. return -EACCES;
  6686. }
  6687. /*
  6688. * Commands dealing with the RAID driver but not any
  6689. * particular array:
  6690. */
  6691. switch (cmd) {
  6692. case RAID_VERSION:
  6693. err = get_version(argp);
  6694. goto out;
  6695. default:;
  6696. }
  6697. /*
  6698. * Commands creating/starting a new array:
  6699. */
  6700. mddev = bdev->bd_disk->private_data;
  6701. if (!mddev) {
  6702. BUG();
  6703. goto out;
  6704. }
  6705. /* Some actions do not requires the mutex */
  6706. switch (cmd) {
  6707. case GET_ARRAY_INFO:
  6708. if (!mddev->raid_disks && !mddev->external)
  6709. err = -ENODEV;
  6710. else
  6711. err = get_array_info(mddev, argp);
  6712. goto out;
  6713. case GET_DISK_INFO:
  6714. if (!mddev->raid_disks && !mddev->external)
  6715. err = -ENODEV;
  6716. else
  6717. err = get_disk_info(mddev, argp);
  6718. goto out;
  6719. case SET_DISK_FAULTY:
  6720. err = set_disk_faulty(mddev, new_decode_dev(arg));
  6721. goto out;
  6722. case GET_BITMAP_FILE:
  6723. err = get_bitmap_file(mddev, argp);
  6724. goto out;
  6725. }
  6726. if (cmd == ADD_NEW_DISK || cmd == HOT_ADD_DISK)
  6727. flush_rdev_wq(mddev);
  6728. if (cmd == HOT_REMOVE_DISK)
  6729. /* need to ensure recovery thread has run */
  6730. wait_event_interruptible_timeout(mddev->sb_wait,
  6731. !test_bit(MD_RECOVERY_NEEDED,
  6732. &mddev->recovery),
  6733. msecs_to_jiffies(5000));
  6734. if (cmd == STOP_ARRAY || cmd == STOP_ARRAY_RO) {
  6735. /* Need to flush page cache, and ensure no-one else opens
  6736. * and writes
  6737. */
  6738. mutex_lock(&mddev->open_mutex);
  6739. if (mddev->pers && atomic_read(&mddev->openers) > 1) {
  6740. mutex_unlock(&mddev->open_mutex);
  6741. err = -EBUSY;
  6742. goto out;
  6743. }
  6744. if (test_and_set_bit(MD_CLOSING, &mddev->flags)) {
  6745. mutex_unlock(&mddev->open_mutex);
  6746. err = -EBUSY;
  6747. goto out;
  6748. }
  6749. did_set_md_closing = true;
  6750. mutex_unlock(&mddev->open_mutex);
  6751. sync_blockdev(bdev);
  6752. }
  6753. err = mddev_lock(mddev);
  6754. if (err) {
  6755. pr_debug("md: ioctl lock interrupted, reason %d, cmd %d\n",
  6756. err, cmd);
  6757. goto out;
  6758. }
  6759. if (cmd == SET_ARRAY_INFO) {
  6760. mdu_array_info_t info;
  6761. if (!arg)
  6762. memset(&info, 0, sizeof(info));
  6763. else if (copy_from_user(&info, argp, sizeof(info))) {
  6764. err = -EFAULT;
  6765. goto unlock;
  6766. }
  6767. if (mddev->pers) {
  6768. err = update_array_info(mddev, &info);
  6769. if (err) {
  6770. pr_warn("md: couldn't update array info. %d\n", err);
  6771. goto unlock;
  6772. }
  6773. goto unlock;
  6774. }
  6775. if (!list_empty(&mddev->disks)) {
  6776. pr_warn("md: array %s already has disks!\n", mdname(mddev));
  6777. err = -EBUSY;
  6778. goto unlock;
  6779. }
  6780. if (mddev->raid_disks) {
  6781. pr_warn("md: array %s already initialised!\n", mdname(mddev));
  6782. err = -EBUSY;
  6783. goto unlock;
  6784. }
  6785. err = md_set_array_info(mddev, &info);
  6786. if (err) {
  6787. pr_warn("md: couldn't set array info. %d\n", err);
  6788. goto unlock;
  6789. }
  6790. goto unlock;
  6791. }
  6792. /*
  6793. * Commands querying/configuring an existing array:
  6794. */
  6795. /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
  6796. * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */
  6797. if ((!mddev->raid_disks && !mddev->external)
  6798. && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
  6799. && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE
  6800. && cmd != GET_BITMAP_FILE) {
  6801. err = -ENODEV;
  6802. goto unlock;
  6803. }
  6804. /*
  6805. * Commands even a read-only array can execute:
  6806. */
  6807. switch (cmd) {
  6808. case RESTART_ARRAY_RW:
  6809. err = restart_array(mddev);
  6810. goto unlock;
  6811. case STOP_ARRAY:
  6812. err = do_md_stop(mddev, 0, bdev);
  6813. goto unlock;
  6814. case STOP_ARRAY_RO:
  6815. err = md_set_readonly(mddev, bdev);
  6816. goto unlock;
  6817. case HOT_REMOVE_DISK:
  6818. err = hot_remove_disk(mddev, new_decode_dev(arg));
  6819. goto unlock;
  6820. case ADD_NEW_DISK:
  6821. /* We can support ADD_NEW_DISK on read-only arrays
  6822. * only if we are re-adding a preexisting device.
  6823. * So require mddev->pers and MD_DISK_SYNC.
  6824. */
  6825. if (mddev->pers) {
  6826. mdu_disk_info_t info;
  6827. if (copy_from_user(&info, argp, sizeof(info)))
  6828. err = -EFAULT;
  6829. else if (!(info.state & (1<<MD_DISK_SYNC)))
  6830. /* Need to clear read-only for this */
  6831. break;
  6832. else
  6833. err = md_add_new_disk(mddev, &info);
  6834. goto unlock;
  6835. }
  6836. break;
  6837. case BLKROSET:
  6838. if (get_user(ro, (int __user *)(arg))) {
  6839. err = -EFAULT;
  6840. goto unlock;
  6841. }
  6842. err = -EINVAL;
  6843. /* if the bdev is going readonly the value of mddev->ro
  6844. * does not matter, no writes are coming
  6845. */
  6846. if (ro)
  6847. goto unlock;
  6848. /* are we are already prepared for writes? */
  6849. if (mddev->ro != 1)
  6850. goto unlock;
  6851. /* transitioning to readauto need only happen for
  6852. * arrays that call md_write_start
  6853. */
  6854. if (mddev->pers) {
  6855. err = restart_array(mddev);
  6856. if (err == 0) {
  6857. mddev->ro = 2;
  6858. set_disk_ro(mddev->gendisk, 0);
  6859. }
  6860. }
  6861. goto unlock;
  6862. }
  6863. /*
  6864. * The remaining ioctls are changing the state of the
  6865. * superblock, so we do not allow them on read-only arrays.
  6866. */
  6867. if (mddev->ro && mddev->pers) {
  6868. if (mddev->ro == 2) {
  6869. mddev->ro = 0;
  6870. sysfs_notify_dirent_safe(mddev->sysfs_state);
  6871. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  6872. /* mddev_unlock will wake thread */
  6873. /* If a device failed while we were read-only, we
  6874. * need to make sure the metadata is updated now.
  6875. */
  6876. if (test_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags)) {
  6877. mddev_unlock(mddev);
  6878. wait_event(mddev->sb_wait,
  6879. !test_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags) &&
  6880. !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));
  6881. mddev_lock_nointr(mddev);
  6882. }
  6883. } else {
  6884. err = -EROFS;
  6885. goto unlock;
  6886. }
  6887. }
  6888. switch (cmd) {
  6889. case ADD_NEW_DISK:
  6890. {
  6891. mdu_disk_info_t info;
  6892. if (copy_from_user(&info, argp, sizeof(info)))
  6893. err = -EFAULT;
  6894. else
  6895. err = md_add_new_disk(mddev, &info);
  6896. goto unlock;
  6897. }
  6898. case CLUSTERED_DISK_NACK:
  6899. if (mddev_is_clustered(mddev))
  6900. md_cluster_ops->new_disk_ack(mddev, false);
  6901. else
  6902. err = -EINVAL;
  6903. goto unlock;
  6904. case HOT_ADD_DISK:
  6905. err = hot_add_disk(mddev, new_decode_dev(arg));
  6906. goto unlock;
  6907. case RUN_ARRAY:
  6908. err = do_md_run(mddev);
  6909. goto unlock;
  6910. case SET_BITMAP_FILE:
  6911. err = set_bitmap_file(mddev, (int)arg);
  6912. goto unlock;
  6913. default:
  6914. err = -EINVAL;
  6915. goto unlock;
  6916. }
  6917. unlock:
  6918. if (mddev->hold_active == UNTIL_IOCTL &&
  6919. err != -EINVAL)
  6920. mddev->hold_active = 0;
  6921. mddev_unlock(mddev);
  6922. out:
  6923. if(did_set_md_closing)
  6924. clear_bit(MD_CLOSING, &mddev->flags);
  6925. return err;
  6926. }
  6927. #ifdef CONFIG_COMPAT
  6928. static int md_compat_ioctl(struct block_device *bdev, fmode_t mode,
  6929. unsigned int cmd, unsigned long arg)
  6930. {
  6931. switch (cmd) {
  6932. case HOT_REMOVE_DISK:
  6933. case HOT_ADD_DISK:
  6934. case SET_DISK_FAULTY:
  6935. case SET_BITMAP_FILE:
  6936. /* These take in integer arg, do not convert */
  6937. break;
  6938. default:
  6939. arg = (unsigned long)compat_ptr(arg);
  6940. break;
  6941. }
  6942. return md_ioctl(bdev, mode, cmd, arg);
  6943. }
  6944. #endif /* CONFIG_COMPAT */
  6945. static int md_open(struct block_device *bdev, fmode_t mode)
  6946. {
  6947. /*
  6948. * Succeed if we can lock the mddev, which confirms that
  6949. * it isn't being stopped right now.
  6950. */
  6951. struct mddev *mddev = mddev_find(bdev->bd_dev);
  6952. int err;
  6953. if (!mddev)
  6954. return -ENODEV;
  6955. if (mddev->gendisk != bdev->bd_disk) {
  6956. /* we are racing with mddev_put which is discarding this
  6957. * bd_disk.
  6958. */
  6959. mddev_put(mddev);
  6960. /* Wait until bdev->bd_disk is definitely gone */
  6961. if (work_pending(&mddev->del_work))
  6962. flush_workqueue(md_misc_wq);
  6963. return -EBUSY;
  6964. }
  6965. BUG_ON(mddev != bdev->bd_disk->private_data);
  6966. if ((err = mutex_lock_interruptible(&mddev->open_mutex)))
  6967. goto out;
  6968. if (test_bit(MD_CLOSING, &mddev->flags)) {
  6969. mutex_unlock(&mddev->open_mutex);
  6970. err = -ENODEV;
  6971. goto out;
  6972. }
  6973. err = 0;
  6974. atomic_inc(&mddev->openers);
  6975. mutex_unlock(&mddev->open_mutex);
  6976. bdev_check_media_change(bdev);
  6977. out:
  6978. if (err)
  6979. mddev_put(mddev);
  6980. return err;
  6981. }
  6982. static void md_release(struct gendisk *disk, fmode_t mode)
  6983. {
  6984. struct mddev *mddev = disk->private_data;
  6985. BUG_ON(!mddev);
  6986. atomic_dec(&mddev->openers);
  6987. mddev_put(mddev);
  6988. }
  6989. static unsigned int md_check_events(struct gendisk *disk, unsigned int clearing)
  6990. {
  6991. struct mddev *mddev = disk->private_data;
  6992. unsigned int ret = 0;
  6993. if (mddev->changed)
  6994. ret = DISK_EVENT_MEDIA_CHANGE;
  6995. mddev->changed = 0;
  6996. return ret;
  6997. }
  6998. const struct block_device_operations md_fops =
  6999. {
  7000. .owner = THIS_MODULE,
  7001. .submit_bio = md_submit_bio,
  7002. .open = md_open,
  7003. .release = md_release,
  7004. .ioctl = md_ioctl,
  7005. #ifdef CONFIG_COMPAT
  7006. .compat_ioctl = md_compat_ioctl,
  7007. #endif
  7008. .getgeo = md_getgeo,
  7009. .check_events = md_check_events,
  7010. };
  7011. static int md_thread(void *arg)
  7012. {
  7013. struct md_thread *thread = arg;
  7014. /*
  7015. * md_thread is a 'system-thread', it's priority should be very
  7016. * high. We avoid resource deadlocks individually in each
  7017. * raid personality. (RAID5 does preallocation) We also use RR and
  7018. * the very same RT priority as kswapd, thus we will never get
  7019. * into a priority inversion deadlock.
  7020. *
  7021. * we definitely have to have equal or higher priority than
  7022. * bdflush, otherwise bdflush will deadlock if there are too
  7023. * many dirty RAID5 blocks.
  7024. */
  7025. allow_signal(SIGKILL);
  7026. while (!kthread_should_stop()) {
  7027. /* We need to wait INTERRUPTIBLE so that
  7028. * we don't add to the load-average.
  7029. * That means we need to be sure no signals are
  7030. * pending
  7031. */
  7032. if (signal_pending(current))
  7033. flush_signals(current);
  7034. wait_event_interruptible_timeout
  7035. (thread->wqueue,
  7036. test_bit(THREAD_WAKEUP, &thread->flags)
  7037. || kthread_should_stop() || kthread_should_park(),
  7038. thread->timeout);
  7039. clear_bit(THREAD_WAKEUP, &thread->flags);
  7040. if (kthread_should_park())
  7041. kthread_parkme();
  7042. if (!kthread_should_stop())
  7043. thread->run(thread);
  7044. }
  7045. return 0;
  7046. }
  7047. void md_wakeup_thread(struct md_thread *thread)
  7048. {
  7049. if (thread) {
  7050. pr_debug("md: waking up MD thread %s.\n", thread->tsk->comm);
  7051. set_bit(THREAD_WAKEUP, &thread->flags);
  7052. wake_up(&thread->wqueue);
  7053. }
  7054. }
  7055. EXPORT_SYMBOL(md_wakeup_thread);
  7056. struct md_thread *md_register_thread(void (*run) (struct md_thread *),
  7057. struct mddev *mddev, const char *name)
  7058. {
  7059. struct md_thread *thread;
  7060. thread = kzalloc(sizeof(struct md_thread), GFP_KERNEL);
  7061. if (!thread)
  7062. return NULL;
  7063. init_waitqueue_head(&thread->wqueue);
  7064. thread->run = run;
  7065. thread->mddev = mddev;
  7066. thread->timeout = MAX_SCHEDULE_TIMEOUT;
  7067. thread->tsk = kthread_run(md_thread, thread,
  7068. "%s_%s",
  7069. mdname(thread->mddev),
  7070. name);
  7071. if (IS_ERR(thread->tsk)) {
  7072. kfree(thread);
  7073. return NULL;
  7074. }
  7075. return thread;
  7076. }
  7077. EXPORT_SYMBOL(md_register_thread);
  7078. void md_unregister_thread(struct md_thread **threadp)
  7079. {
  7080. struct md_thread *thread = *threadp;
  7081. if (!thread)
  7082. return;
  7083. pr_debug("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
  7084. /* Locking ensures that mddev_unlock does not wake_up a
  7085. * non-existent thread
  7086. */
  7087. spin_lock(&pers_lock);
  7088. *threadp = NULL;
  7089. spin_unlock(&pers_lock);
  7090. kthread_stop(thread->tsk);
  7091. kfree(thread);
  7092. }
  7093. EXPORT_SYMBOL(md_unregister_thread);
  7094. void md_error(struct mddev *mddev, struct md_rdev *rdev)
  7095. {
  7096. if (!rdev || test_bit(Faulty, &rdev->flags))
  7097. return;
  7098. if (!mddev->pers || !mddev->pers->error_handler)
  7099. return;
  7100. mddev->pers->error_handler(mddev,rdev);
  7101. if (mddev->degraded)
  7102. set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
  7103. sysfs_notify_dirent_safe(rdev->sysfs_state);
  7104. set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  7105. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  7106. md_wakeup_thread(mddev->thread);
  7107. if (mddev->event_work.func)
  7108. queue_work(md_misc_wq, &mddev->event_work);
  7109. md_new_event(mddev);
  7110. }
  7111. EXPORT_SYMBOL(md_error);
  7112. /* seq_file implementation /proc/mdstat */
  7113. static void status_unused(struct seq_file *seq)
  7114. {
  7115. int i = 0;
  7116. struct md_rdev *rdev;
  7117. seq_printf(seq, "unused devices: ");
  7118. list_for_each_entry(rdev, &pending_raid_disks, same_set) {
  7119. char b[BDEVNAME_SIZE];
  7120. i++;
  7121. seq_printf(seq, "%s ",
  7122. bdevname(rdev->bdev,b));
  7123. }
  7124. if (!i)
  7125. seq_printf(seq, "<none>");
  7126. seq_printf(seq, "\n");
  7127. }
  7128. static int status_resync(struct seq_file *seq, struct mddev *mddev)
  7129. {
  7130. sector_t max_sectors, resync, res;
  7131. unsigned long dt, db = 0;
  7132. sector_t rt, curr_mark_cnt, resync_mark_cnt;
  7133. int scale, recovery_active;
  7134. unsigned int per_milli;
  7135. if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
  7136. test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
  7137. max_sectors = mddev->resync_max_sectors;
  7138. else
  7139. max_sectors = mddev->dev_sectors;
  7140. resync = mddev->curr_resync;
  7141. if (resync <= 3) {
  7142. if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
  7143. /* Still cleaning up */
  7144. resync = max_sectors;
  7145. } else if (resync > max_sectors)
  7146. resync = max_sectors;
  7147. else
  7148. resync -= atomic_read(&mddev->recovery_active);
  7149. if (resync == 0) {
  7150. if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery)) {
  7151. struct md_rdev *rdev;
  7152. rdev_for_each(rdev, mddev)
  7153. if (rdev->raid_disk >= 0 &&
  7154. !test_bit(Faulty, &rdev->flags) &&
  7155. rdev->recovery_offset != MaxSector &&
  7156. rdev->recovery_offset) {
  7157. seq_printf(seq, "\trecover=REMOTE");
  7158. return 1;
  7159. }
  7160. if (mddev->reshape_position != MaxSector)
  7161. seq_printf(seq, "\treshape=REMOTE");
  7162. else
  7163. seq_printf(seq, "\tresync=REMOTE");
  7164. return 1;
  7165. }
  7166. if (mddev->recovery_cp < MaxSector) {
  7167. seq_printf(seq, "\tresync=PENDING");
  7168. return 1;
  7169. }
  7170. return 0;
  7171. }
  7172. if (resync < 3) {
  7173. seq_printf(seq, "\tresync=DELAYED");
  7174. return 1;
  7175. }
  7176. WARN_ON(max_sectors == 0);
  7177. /* Pick 'scale' such that (resync>>scale)*1000 will fit
  7178. * in a sector_t, and (max_sectors>>scale) will fit in a
  7179. * u32, as those are the requirements for sector_div.
  7180. * Thus 'scale' must be at least 10
  7181. */
  7182. scale = 10;
  7183. if (sizeof(sector_t) > sizeof(unsigned long)) {
  7184. while ( max_sectors/2 > (1ULL<<(scale+32)))
  7185. scale++;
  7186. }
  7187. res = (resync>>scale)*1000;
  7188. sector_div(res, (u32)((max_sectors>>scale)+1));
  7189. per_milli = res;
  7190. {
  7191. int i, x = per_milli/50, y = 20-x;
  7192. seq_printf(seq, "[");
  7193. for (i = 0; i < x; i++)
  7194. seq_printf(seq, "=");
  7195. seq_printf(seq, ">");
  7196. for (i = 0; i < y; i++)
  7197. seq_printf(seq, ".");
  7198. seq_printf(seq, "] ");
  7199. }
  7200. seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
  7201. (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
  7202. "reshape" :
  7203. (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
  7204. "check" :
  7205. (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
  7206. "resync" : "recovery"))),
  7207. per_milli/10, per_milli % 10,
  7208. (unsigned long long) resync/2,
  7209. (unsigned long long) max_sectors/2);
  7210. /*
  7211. * dt: time from mark until now
  7212. * db: blocks written from mark until now
  7213. * rt: remaining time
  7214. *
  7215. * rt is a sector_t, which is always 64bit now. We are keeping
  7216. * the original algorithm, but it is not really necessary.
  7217. *
  7218. * Original algorithm:
  7219. * So we divide before multiply in case it is 32bit and close
  7220. * to the limit.
  7221. * We scale the divisor (db) by 32 to avoid losing precision
  7222. * near the end of resync when the number of remaining sectors
  7223. * is close to 'db'.
  7224. * We then divide rt by 32 after multiplying by db to compensate.
  7225. * The '+1' avoids division by zero if db is very small.
  7226. */
  7227. dt = ((jiffies - mddev->resync_mark) / HZ);
  7228. if (!dt) dt++;
  7229. curr_mark_cnt = mddev->curr_mark_cnt;
  7230. recovery_active = atomic_read(&mddev->recovery_active);
  7231. resync_mark_cnt = mddev->resync_mark_cnt;
  7232. if (curr_mark_cnt >= (recovery_active + resync_mark_cnt))
  7233. db = curr_mark_cnt - (recovery_active + resync_mark_cnt);
  7234. rt = max_sectors - resync; /* number of remaining sectors */
  7235. rt = div64_u64(rt, db/32+1);
  7236. rt *= dt;
  7237. rt >>= 5;
  7238. seq_printf(seq, " finish=%lu.%lumin", (unsigned long)rt / 60,
  7239. ((unsigned long)rt % 60)/6);
  7240. seq_printf(seq, " speed=%ldK/sec", db/2/dt);
  7241. return 1;
  7242. }
  7243. static void *md_seq_start(struct seq_file *seq, loff_t *pos)
  7244. {
  7245. struct list_head *tmp;
  7246. loff_t l = *pos;
  7247. struct mddev *mddev;
  7248. if (l == 0x10000) {
  7249. ++*pos;
  7250. return (void *)2;
  7251. }
  7252. if (l > 0x10000)
  7253. return NULL;
  7254. if (!l--)
  7255. /* header */
  7256. return (void*)1;
  7257. spin_lock(&all_mddevs_lock);
  7258. list_for_each(tmp,&all_mddevs)
  7259. if (!l--) {
  7260. mddev = list_entry(tmp, struct mddev, all_mddevs);
  7261. mddev_get(mddev);
  7262. spin_unlock(&all_mddevs_lock);
  7263. return mddev;
  7264. }
  7265. spin_unlock(&all_mddevs_lock);
  7266. if (!l--)
  7267. return (void*)2;/* tail */
  7268. return NULL;
  7269. }
  7270. static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  7271. {
  7272. struct list_head *tmp;
  7273. struct mddev *next_mddev, *mddev = v;
  7274. ++*pos;
  7275. if (v == (void*)2)
  7276. return NULL;
  7277. spin_lock(&all_mddevs_lock);
  7278. if (v == (void*)1)
  7279. tmp = all_mddevs.next;
  7280. else
  7281. tmp = mddev->all_mddevs.next;
  7282. if (tmp != &all_mddevs)
  7283. next_mddev = mddev_get(list_entry(tmp,struct mddev,all_mddevs));
  7284. else {
  7285. next_mddev = (void*)2;
  7286. *pos = 0x10000;
  7287. }
  7288. spin_unlock(&all_mddevs_lock);
  7289. if (v != (void*)1)
  7290. mddev_put(mddev);
  7291. return next_mddev;
  7292. }
  7293. static void md_seq_stop(struct seq_file *seq, void *v)
  7294. {
  7295. struct mddev *mddev = v;
  7296. if (mddev && v != (void*)1 && v != (void*)2)
  7297. mddev_put(mddev);
  7298. }
  7299. static int md_seq_show(struct seq_file *seq, void *v)
  7300. {
  7301. struct mddev *mddev = v;
  7302. sector_t sectors;
  7303. struct md_rdev *rdev;
  7304. if (v == (void*)1) {
  7305. struct md_personality *pers;
  7306. seq_printf(seq, "Personalities : ");
  7307. spin_lock(&pers_lock);
  7308. list_for_each_entry(pers, &pers_list, list)
  7309. seq_printf(seq, "[%s] ", pers->name);
  7310. spin_unlock(&pers_lock);
  7311. seq_printf(seq, "\n");
  7312. seq->poll_event = atomic_read(&md_event_count);
  7313. return 0;
  7314. }
  7315. if (v == (void*)2) {
  7316. status_unused(seq);
  7317. return 0;
  7318. }
  7319. spin_lock(&mddev->lock);
  7320. if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
  7321. seq_printf(seq, "%s : %sactive", mdname(mddev),
  7322. mddev->pers ? "" : "in");
  7323. if (mddev->pers) {
  7324. if (mddev->ro==1)
  7325. seq_printf(seq, " (read-only)");
  7326. if (mddev->ro==2)
  7327. seq_printf(seq, " (auto-read-only)");
  7328. seq_printf(seq, " %s", mddev->pers->name);
  7329. }
  7330. sectors = 0;
  7331. rcu_read_lock();
  7332. rdev_for_each_rcu(rdev, mddev) {
  7333. char b[BDEVNAME_SIZE];
  7334. seq_printf(seq, " %s[%d]",
  7335. bdevname(rdev->bdev,b), rdev->desc_nr);
  7336. if (test_bit(WriteMostly, &rdev->flags))
  7337. seq_printf(seq, "(W)");
  7338. if (test_bit(Journal, &rdev->flags))
  7339. seq_printf(seq, "(J)");
  7340. if (test_bit(Faulty, &rdev->flags)) {
  7341. seq_printf(seq, "(F)");
  7342. continue;
  7343. }
  7344. if (rdev->raid_disk < 0)
  7345. seq_printf(seq, "(S)"); /* spare */
  7346. if (test_bit(Replacement, &rdev->flags))
  7347. seq_printf(seq, "(R)");
  7348. sectors += rdev->sectors;
  7349. }
  7350. rcu_read_unlock();
  7351. if (!list_empty(&mddev->disks)) {
  7352. if (mddev->pers)
  7353. seq_printf(seq, "\n %llu blocks",
  7354. (unsigned long long)
  7355. mddev->array_sectors / 2);
  7356. else
  7357. seq_printf(seq, "\n %llu blocks",
  7358. (unsigned long long)sectors / 2);
  7359. }
  7360. if (mddev->persistent) {
  7361. if (mddev->major_version != 0 ||
  7362. mddev->minor_version != 90) {
  7363. seq_printf(seq," super %d.%d",
  7364. mddev->major_version,
  7365. mddev->minor_version);
  7366. }
  7367. } else if (mddev->external)
  7368. seq_printf(seq, " super external:%s",
  7369. mddev->metadata_type);
  7370. else
  7371. seq_printf(seq, " super non-persistent");
  7372. if (mddev->pers) {
  7373. mddev->pers->status(seq, mddev);
  7374. seq_printf(seq, "\n ");
  7375. if (mddev->pers->sync_request) {
  7376. if (status_resync(seq, mddev))
  7377. seq_printf(seq, "\n ");
  7378. }
  7379. } else
  7380. seq_printf(seq, "\n ");
  7381. md_bitmap_status(seq, mddev->bitmap);
  7382. seq_printf(seq, "\n");
  7383. }
  7384. spin_unlock(&mddev->lock);
  7385. return 0;
  7386. }
  7387. static const struct seq_operations md_seq_ops = {
  7388. .start = md_seq_start,
  7389. .next = md_seq_next,
  7390. .stop = md_seq_stop,
  7391. .show = md_seq_show,
  7392. };
  7393. static int md_seq_open(struct inode *inode, struct file *file)
  7394. {
  7395. struct seq_file *seq;
  7396. int error;
  7397. error = seq_open(file, &md_seq_ops);
  7398. if (error)
  7399. return error;
  7400. seq = file->private_data;
  7401. seq->poll_event = atomic_read(&md_event_count);
  7402. return error;
  7403. }
  7404. static int md_unloading;
  7405. static __poll_t mdstat_poll(struct file *filp, poll_table *wait)
  7406. {
  7407. struct seq_file *seq = filp->private_data;
  7408. __poll_t mask;
  7409. if (md_unloading)
  7410. return EPOLLIN|EPOLLRDNORM|EPOLLERR|EPOLLPRI;
  7411. poll_wait(filp, &md_event_waiters, wait);
  7412. /* always allow read */
  7413. mask = EPOLLIN | EPOLLRDNORM;
  7414. if (seq->poll_event != atomic_read(&md_event_count))
  7415. mask |= EPOLLERR | EPOLLPRI;
  7416. return mask;
  7417. }
  7418. static const struct proc_ops mdstat_proc_ops = {
  7419. .proc_open = md_seq_open,
  7420. .proc_read = seq_read,
  7421. .proc_lseek = seq_lseek,
  7422. .proc_release = seq_release,
  7423. .proc_poll = mdstat_poll,
  7424. };
  7425. int register_md_personality(struct md_personality *p)
  7426. {
  7427. pr_debug("md: %s personality registered for level %d\n",
  7428. p->name, p->level);
  7429. spin_lock(&pers_lock);
  7430. list_add_tail(&p->list, &pers_list);
  7431. spin_unlock(&pers_lock);
  7432. return 0;
  7433. }
  7434. EXPORT_SYMBOL(register_md_personality);
  7435. int unregister_md_personality(struct md_personality *p)
  7436. {
  7437. pr_debug("md: %s personality unregistered\n", p->name);
  7438. spin_lock(&pers_lock);
  7439. list_del_init(&p->list);
  7440. spin_unlock(&pers_lock);
  7441. return 0;
  7442. }
  7443. EXPORT_SYMBOL(unregister_md_personality);
  7444. int register_md_cluster_operations(struct md_cluster_operations *ops,
  7445. struct module *module)
  7446. {
  7447. int ret = 0;
  7448. spin_lock(&pers_lock);
  7449. if (md_cluster_ops != NULL)
  7450. ret = -EALREADY;
  7451. else {
  7452. md_cluster_ops = ops;
  7453. md_cluster_mod = module;
  7454. }
  7455. spin_unlock(&pers_lock);
  7456. return ret;
  7457. }
  7458. EXPORT_SYMBOL(register_md_cluster_operations);
  7459. int unregister_md_cluster_operations(void)
  7460. {
  7461. spin_lock(&pers_lock);
  7462. md_cluster_ops = NULL;
  7463. spin_unlock(&pers_lock);
  7464. return 0;
  7465. }
  7466. EXPORT_SYMBOL(unregister_md_cluster_operations);
  7467. int md_setup_cluster(struct mddev *mddev, int nodes)
  7468. {
  7469. int ret;
  7470. if (!md_cluster_ops)
  7471. request_module("md-cluster");
  7472. spin_lock(&pers_lock);
  7473. /* ensure module won't be unloaded */
  7474. if (!md_cluster_ops || !try_module_get(md_cluster_mod)) {
  7475. pr_warn("can't find md-cluster module or get it's reference.\n");
  7476. spin_unlock(&pers_lock);
  7477. return -ENOENT;
  7478. }
  7479. spin_unlock(&pers_lock);
  7480. ret = md_cluster_ops->join(mddev, nodes);
  7481. if (!ret)
  7482. mddev->safemode_delay = 0;
  7483. return ret;
  7484. }
  7485. void md_cluster_stop(struct mddev *mddev)
  7486. {
  7487. if (!md_cluster_ops)
  7488. return;
  7489. md_cluster_ops->leave(mddev);
  7490. module_put(md_cluster_mod);
  7491. }
  7492. static int is_mddev_idle(struct mddev *mddev, int init)
  7493. {
  7494. struct md_rdev *rdev;
  7495. int idle;
  7496. int curr_events;
  7497. idle = 1;
  7498. rcu_read_lock();
  7499. rdev_for_each_rcu(rdev, mddev) {
  7500. struct gendisk *disk = rdev->bdev->bd_disk;
  7501. curr_events = (int)part_stat_read_accum(&disk->part0, sectors) -
  7502. atomic_read(&disk->sync_io);
  7503. /* sync IO will cause sync_io to increase before the disk_stats
  7504. * as sync_io is counted when a request starts, and
  7505. * disk_stats is counted when it completes.
  7506. * So resync activity will cause curr_events to be smaller than
  7507. * when there was no such activity.
  7508. * non-sync IO will cause disk_stat to increase without
  7509. * increasing sync_io so curr_events will (eventually)
  7510. * be larger than it was before. Once it becomes
  7511. * substantially larger, the test below will cause
  7512. * the array to appear non-idle, and resync will slow
  7513. * down.
  7514. * If there is a lot of outstanding resync activity when
  7515. * we set last_event to curr_events, then all that activity
  7516. * completing might cause the array to appear non-idle
  7517. * and resync will be slowed down even though there might
  7518. * not have been non-resync activity. This will only
  7519. * happen once though. 'last_events' will soon reflect
  7520. * the state where there is little or no outstanding
  7521. * resync requests, and further resync activity will
  7522. * always make curr_events less than last_events.
  7523. *
  7524. */
  7525. if (init || curr_events - rdev->last_events > 64) {
  7526. rdev->last_events = curr_events;
  7527. idle = 0;
  7528. }
  7529. }
  7530. rcu_read_unlock();
  7531. return idle;
  7532. }
  7533. void md_done_sync(struct mddev *mddev, int blocks, int ok)
  7534. {
  7535. /* another "blocks" (512byte) blocks have been synced */
  7536. atomic_sub(blocks, &mddev->recovery_active);
  7537. wake_up(&mddev->recovery_wait);
  7538. if (!ok) {
  7539. set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  7540. set_bit(MD_RECOVERY_ERROR, &mddev->recovery);
  7541. md_wakeup_thread(mddev->thread);
  7542. // stop recovery, signal do_sync ....
  7543. }
  7544. }
  7545. EXPORT_SYMBOL(md_done_sync);
  7546. /* md_write_start(mddev, bi)
  7547. * If we need to update some array metadata (e.g. 'active' flag
  7548. * in superblock) before writing, schedule a superblock update
  7549. * and wait for it to complete.
  7550. * A return value of 'false' means that the write wasn't recorded
  7551. * and cannot proceed as the array is being suspend.
  7552. */
  7553. bool md_write_start(struct mddev *mddev, struct bio *bi)
  7554. {
  7555. int did_change = 0;
  7556. if (bio_data_dir(bi) != WRITE)
  7557. return true;
  7558. BUG_ON(mddev->ro == 1);
  7559. if (mddev->ro == 2) {
  7560. /* need to switch to read/write */
  7561. mddev->ro = 0;
  7562. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  7563. md_wakeup_thread(mddev->thread);
  7564. md_wakeup_thread(mddev->sync_thread);
  7565. did_change = 1;
  7566. }
  7567. rcu_read_lock();
  7568. percpu_ref_get(&mddev->writes_pending);
  7569. smp_mb(); /* Match smp_mb in set_in_sync() */
  7570. if (mddev->safemode == 1)
  7571. mddev->safemode = 0;
  7572. /* sync_checkers is always 0 when writes_pending is in per-cpu mode */
  7573. if (mddev->in_sync || mddev->sync_checkers) {
  7574. spin_lock(&mddev->lock);
  7575. if (mddev->in_sync) {
  7576. mddev->in_sync = 0;
  7577. set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
  7578. set_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
  7579. md_wakeup_thread(mddev->thread);
  7580. did_change = 1;
  7581. }
  7582. spin_unlock(&mddev->lock);
  7583. }
  7584. rcu_read_unlock();
  7585. if (did_change)
  7586. sysfs_notify_dirent_safe(mddev->sysfs_state);
  7587. if (!mddev->has_superblocks)
  7588. return true;
  7589. wait_event(mddev->sb_wait,
  7590. !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags) ||
  7591. mddev->suspended);
  7592. if (test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags)) {
  7593. percpu_ref_put(&mddev->writes_pending);
  7594. return false;
  7595. }
  7596. return true;
  7597. }
  7598. EXPORT_SYMBOL(md_write_start);
  7599. /* md_write_inc can only be called when md_write_start() has
  7600. * already been called at least once of the current request.
  7601. * It increments the counter and is useful when a single request
  7602. * is split into several parts. Each part causes an increment and
  7603. * so needs a matching md_write_end().
  7604. * Unlike md_write_start(), it is safe to call md_write_inc() inside
  7605. * a spinlocked region.
  7606. */
  7607. void md_write_inc(struct mddev *mddev, struct bio *bi)
  7608. {
  7609. if (bio_data_dir(bi) != WRITE)
  7610. return;
  7611. WARN_ON_ONCE(mddev->in_sync || mddev->ro);
  7612. percpu_ref_get(&mddev->writes_pending);
  7613. }
  7614. EXPORT_SYMBOL(md_write_inc);
  7615. void md_write_end(struct mddev *mddev)
  7616. {
  7617. percpu_ref_put(&mddev->writes_pending);
  7618. if (mddev->safemode == 2)
  7619. md_wakeup_thread(mddev->thread);
  7620. else if (mddev->safemode_delay)
  7621. /* The roundup() ensures this only performs locking once
  7622. * every ->safemode_delay jiffies
  7623. */
  7624. mod_timer(&mddev->safemode_timer,
  7625. roundup(jiffies, mddev->safemode_delay) +
  7626. mddev->safemode_delay);
  7627. }
  7628. EXPORT_SYMBOL(md_write_end);
  7629. /* md_allow_write(mddev)
  7630. * Calling this ensures that the array is marked 'active' so that writes
  7631. * may proceed without blocking. It is important to call this before
  7632. * attempting a GFP_KERNEL allocation while holding the mddev lock.
  7633. * Must be called with mddev_lock held.
  7634. */
  7635. void md_allow_write(struct mddev *mddev)
  7636. {
  7637. if (!mddev->pers)
  7638. return;
  7639. if (mddev->ro)
  7640. return;
  7641. if (!mddev->pers->sync_request)
  7642. return;
  7643. spin_lock(&mddev->lock);
  7644. if (mddev->in_sync) {
  7645. mddev->in_sync = 0;
  7646. set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
  7647. set_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
  7648. if (mddev->safemode_delay &&
  7649. mddev->safemode == 0)
  7650. mddev->safemode = 1;
  7651. spin_unlock(&mddev->lock);
  7652. md_update_sb(mddev, 0);
  7653. sysfs_notify_dirent_safe(mddev->sysfs_state);
  7654. /* wait for the dirty state to be recorded in the metadata */
  7655. wait_event(mddev->sb_wait,
  7656. !test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags));
  7657. } else
  7658. spin_unlock(&mddev->lock);
  7659. }
  7660. EXPORT_SYMBOL_GPL(md_allow_write);
  7661. #define SYNC_MARKS 10
  7662. #define SYNC_MARK_STEP (3*HZ)
  7663. #define UPDATE_FREQUENCY (5*60*HZ)
  7664. void md_do_sync(struct md_thread *thread)
  7665. {
  7666. struct mddev *mddev = thread->mddev;
  7667. struct mddev *mddev2;
  7668. unsigned int currspeed = 0, window;
  7669. sector_t max_sectors,j, io_sectors, recovery_done;
  7670. unsigned long mark[SYNC_MARKS];
  7671. unsigned long update_time;
  7672. sector_t mark_cnt[SYNC_MARKS];
  7673. int last_mark,m;
  7674. struct list_head *tmp;
  7675. sector_t last_check;
  7676. int skipped = 0;
  7677. struct md_rdev *rdev;
  7678. char *desc, *action = NULL;
  7679. struct blk_plug plug;
  7680. int ret;
  7681. /* just incase thread restarts... */
  7682. if (test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
  7683. test_bit(MD_RECOVERY_WAIT, &mddev->recovery))
  7684. return;
  7685. if (mddev->ro) {/* never try to sync a read-only array */
  7686. set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  7687. return;
  7688. }
  7689. if (mddev_is_clustered(mddev)) {
  7690. ret = md_cluster_ops->resync_start(mddev);
  7691. if (ret)
  7692. goto skip;
  7693. set_bit(MD_CLUSTER_RESYNC_LOCKED, &mddev->flags);
  7694. if (!(test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ||
  7695. test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) ||
  7696. test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))
  7697. && ((unsigned long long)mddev->curr_resync_completed
  7698. < (unsigned long long)mddev->resync_max_sectors))
  7699. goto skip;
  7700. }
  7701. if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
  7702. if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)) {
  7703. desc = "data-check";
  7704. action = "check";
  7705. } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
  7706. desc = "requested-resync";
  7707. action = "repair";
  7708. } else
  7709. desc = "resync";
  7710. } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
  7711. desc = "reshape";
  7712. else
  7713. desc = "recovery";
  7714. mddev->last_sync_action = action ?: desc;
  7715. /* we overload curr_resync somewhat here.
  7716. * 0 == not engaged in resync at all
  7717. * 2 == checking that there is no conflict with another sync
  7718. * 1 == like 2, but have yielded to allow conflicting resync to
  7719. * commence
  7720. * other == active in resync - this many blocks
  7721. *
  7722. * Before starting a resync we must have set curr_resync to
  7723. * 2, and then checked that every "conflicting" array has curr_resync
  7724. * less than ours. When we find one that is the same or higher
  7725. * we wait on resync_wait. To avoid deadlock, we reduce curr_resync
  7726. * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
  7727. * This will mean we have to start checking from the beginning again.
  7728. *
  7729. */
  7730. do {
  7731. int mddev2_minor = -1;
  7732. mddev->curr_resync = 2;
  7733. try_again:
  7734. if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
  7735. goto skip;
  7736. for_each_mddev(mddev2, tmp) {
  7737. if (mddev2 == mddev)
  7738. continue;
  7739. if (!mddev->parallel_resync
  7740. && mddev2->curr_resync
  7741. && match_mddev_units(mddev, mddev2)) {
  7742. DEFINE_WAIT(wq);
  7743. if (mddev < mddev2 && mddev->curr_resync == 2) {
  7744. /* arbitrarily yield */
  7745. mddev->curr_resync = 1;
  7746. wake_up(&resync_wait);
  7747. }
  7748. if (mddev > mddev2 && mddev->curr_resync == 1)
  7749. /* no need to wait here, we can wait the next
  7750. * time 'round when curr_resync == 2
  7751. */
  7752. continue;
  7753. /* We need to wait 'interruptible' so as not to
  7754. * contribute to the load average, and not to
  7755. * be caught by 'softlockup'
  7756. */
  7757. prepare_to_wait(&resync_wait, &wq, TASK_INTERRUPTIBLE);
  7758. if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
  7759. mddev2->curr_resync >= mddev->curr_resync) {
  7760. if (mddev2_minor != mddev2->md_minor) {
  7761. mddev2_minor = mddev2->md_minor;
  7762. pr_info("md: delaying %s of %s until %s has finished (they share one or more physical units)\n",
  7763. desc, mdname(mddev),
  7764. mdname(mddev2));
  7765. }
  7766. mddev_put(mddev2);
  7767. if (signal_pending(current))
  7768. flush_signals(current);
  7769. schedule();
  7770. finish_wait(&resync_wait, &wq);
  7771. goto try_again;
  7772. }
  7773. finish_wait(&resync_wait, &wq);
  7774. }
  7775. }
  7776. } while (mddev->curr_resync < 2);
  7777. j = 0;
  7778. if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
  7779. /* resync follows the size requested by the personality,
  7780. * which defaults to physical size, but can be virtual size
  7781. */
  7782. max_sectors = mddev->resync_max_sectors;
  7783. atomic64_set(&mddev->resync_mismatches, 0);
  7784. /* we don't use the checkpoint if there's a bitmap */
  7785. if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
  7786. j = mddev->resync_min;
  7787. else if (!mddev->bitmap)
  7788. j = mddev->recovery_cp;
  7789. } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)) {
  7790. max_sectors = mddev->resync_max_sectors;
  7791. /*
  7792. * If the original node aborts reshaping then we continue the
  7793. * reshaping, so set j again to avoid restart reshape from the
  7794. * first beginning
  7795. */
  7796. if (mddev_is_clustered(mddev) &&
  7797. mddev->reshape_position != MaxSector)
  7798. j = mddev->reshape_position;
  7799. } else {
  7800. /* recovery follows the physical size of devices */
  7801. max_sectors = mddev->dev_sectors;
  7802. j = MaxSector;
  7803. rcu_read_lock();
  7804. rdev_for_each_rcu(rdev, mddev)
  7805. if (rdev->raid_disk >= 0 &&
  7806. !test_bit(Journal, &rdev->flags) &&
  7807. !test_bit(Faulty, &rdev->flags) &&
  7808. !test_bit(In_sync, &rdev->flags) &&
  7809. rdev->recovery_offset < j)
  7810. j = rdev->recovery_offset;
  7811. rcu_read_unlock();
  7812. /* If there is a bitmap, we need to make sure all
  7813. * writes that started before we added a spare
  7814. * complete before we start doing a recovery.
  7815. * Otherwise the write might complete and (via
  7816. * bitmap_endwrite) set a bit in the bitmap after the
  7817. * recovery has checked that bit and skipped that
  7818. * region.
  7819. */
  7820. if (mddev->bitmap) {
  7821. mddev->pers->quiesce(mddev, 1);
  7822. mddev->pers->quiesce(mddev, 0);
  7823. }
  7824. }
  7825. pr_info("md: %s of RAID array %s\n", desc, mdname(mddev));
  7826. pr_debug("md: minimum _guaranteed_ speed: %d KB/sec/disk.\n", speed_min(mddev));
  7827. pr_debug("md: using maximum available idle IO bandwidth (but not more than %d KB/sec) for %s.\n",
  7828. speed_max(mddev), desc);
  7829. is_mddev_idle(mddev, 1); /* this initializes IO event counters */
  7830. io_sectors = 0;
  7831. for (m = 0; m < SYNC_MARKS; m++) {
  7832. mark[m] = jiffies;
  7833. mark_cnt[m] = io_sectors;
  7834. }
  7835. last_mark = 0;
  7836. mddev->resync_mark = mark[last_mark];
  7837. mddev->resync_mark_cnt = mark_cnt[last_mark];
  7838. /*
  7839. * Tune reconstruction:
  7840. */
  7841. window = 32 * (PAGE_SIZE / 512);
  7842. pr_debug("md: using %dk window, over a total of %lluk.\n",
  7843. window/2, (unsigned long long)max_sectors/2);
  7844. atomic_set(&mddev->recovery_active, 0);
  7845. last_check = 0;
  7846. if (j>2) {
  7847. pr_debug("md: resuming %s of %s from checkpoint.\n",
  7848. desc, mdname(mddev));
  7849. mddev->curr_resync = j;
  7850. } else
  7851. mddev->curr_resync = 3; /* no longer delayed */
  7852. mddev->curr_resync_completed = j;
  7853. sysfs_notify_dirent_safe(mddev->sysfs_completed);
  7854. md_new_event(mddev);
  7855. update_time = jiffies;
  7856. blk_start_plug(&plug);
  7857. while (j < max_sectors) {
  7858. sector_t sectors;
  7859. skipped = 0;
  7860. if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
  7861. ((mddev->curr_resync > mddev->curr_resync_completed &&
  7862. (mddev->curr_resync - mddev->curr_resync_completed)
  7863. > (max_sectors >> 4)) ||
  7864. time_after_eq(jiffies, update_time + UPDATE_FREQUENCY) ||
  7865. (j - mddev->curr_resync_completed)*2
  7866. >= mddev->resync_max - mddev->curr_resync_completed ||
  7867. mddev->curr_resync_completed > mddev->resync_max
  7868. )) {
  7869. /* time to update curr_resync_completed */
  7870. wait_event(mddev->recovery_wait,
  7871. atomic_read(&mddev->recovery_active) == 0);
  7872. mddev->curr_resync_completed = j;
  7873. if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) &&
  7874. j > mddev->recovery_cp)
  7875. mddev->recovery_cp = j;
  7876. update_time = jiffies;
  7877. set_bit(MD_SB_CHANGE_CLEAN, &mddev->sb_flags);
  7878. sysfs_notify_dirent_safe(mddev->sysfs_completed);
  7879. }
  7880. while (j >= mddev->resync_max &&
  7881. !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
  7882. /* As this condition is controlled by user-space,
  7883. * we can block indefinitely, so use '_interruptible'
  7884. * to avoid triggering warnings.
  7885. */
  7886. flush_signals(current); /* just in case */
  7887. wait_event_interruptible(mddev->recovery_wait,
  7888. mddev->resync_max > j
  7889. || test_bit(MD_RECOVERY_INTR,
  7890. &mddev->recovery));
  7891. }
  7892. if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
  7893. break;
  7894. sectors = mddev->pers->sync_request(mddev, j, &skipped);
  7895. if (sectors == 0) {
  7896. set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  7897. break;
  7898. }
  7899. if (!skipped) { /* actual IO requested */
  7900. io_sectors += sectors;
  7901. atomic_add(sectors, &mddev->recovery_active);
  7902. }
  7903. if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
  7904. break;
  7905. j += sectors;
  7906. if (j > max_sectors)
  7907. /* when skipping, extra large numbers can be returned. */
  7908. j = max_sectors;
  7909. if (j > 2)
  7910. mddev->curr_resync = j;
  7911. mddev->curr_mark_cnt = io_sectors;
  7912. if (last_check == 0)
  7913. /* this is the earliest that rebuild will be
  7914. * visible in /proc/mdstat
  7915. */
  7916. md_new_event(mddev);
  7917. if (last_check + window > io_sectors || j == max_sectors)
  7918. continue;
  7919. last_check = io_sectors;
  7920. repeat:
  7921. if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
  7922. /* step marks */
  7923. int next = (last_mark+1) % SYNC_MARKS;
  7924. mddev->resync_mark = mark[next];
  7925. mddev->resync_mark_cnt = mark_cnt[next];
  7926. mark[next] = jiffies;
  7927. mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
  7928. last_mark = next;
  7929. }
  7930. if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
  7931. break;
  7932. /*
  7933. * this loop exits only if either when we are slower than
  7934. * the 'hard' speed limit, or the system was IO-idle for
  7935. * a jiffy.
  7936. * the system might be non-idle CPU-wise, but we only care
  7937. * about not overloading the IO subsystem. (things like an
  7938. * e2fsck being done on the RAID array should execute fast)
  7939. */
  7940. cond_resched();
  7941. recovery_done = io_sectors - atomic_read(&mddev->recovery_active);
  7942. currspeed = ((unsigned long)(recovery_done - mddev->resync_mark_cnt))/2
  7943. /((jiffies-mddev->resync_mark)/HZ +1) +1;
  7944. if (currspeed > speed_min(mddev)) {
  7945. if (currspeed > speed_max(mddev)) {
  7946. msleep(500);
  7947. goto repeat;
  7948. }
  7949. if (!is_mddev_idle(mddev, 0)) {
  7950. /*
  7951. * Give other IO more of a chance.
  7952. * The faster the devices, the less we wait.
  7953. */
  7954. wait_event(mddev->recovery_wait,
  7955. !atomic_read(&mddev->recovery_active));
  7956. }
  7957. }
  7958. }
  7959. pr_info("md: %s: %s %s.\n",mdname(mddev), desc,
  7960. test_bit(MD_RECOVERY_INTR, &mddev->recovery)
  7961. ? "interrupted" : "done");
  7962. /*
  7963. * this also signals 'finished resyncing' to md_stop
  7964. */
  7965. blk_finish_plug(&plug);
  7966. wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
  7967. if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
  7968. !test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
  7969. mddev->curr_resync > 3) {
  7970. mddev->curr_resync_completed = mddev->curr_resync;
  7971. sysfs_notify_dirent_safe(mddev->sysfs_completed);
  7972. }
  7973. mddev->pers->sync_request(mddev, max_sectors, &skipped);
  7974. if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
  7975. mddev->curr_resync > 3) {
  7976. if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
  7977. if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
  7978. if (mddev->curr_resync >= mddev->recovery_cp) {
  7979. pr_debug("md: checkpointing %s of %s.\n",
  7980. desc, mdname(mddev));
  7981. if (test_bit(MD_RECOVERY_ERROR,
  7982. &mddev->recovery))
  7983. mddev->recovery_cp =
  7984. mddev->curr_resync_completed;
  7985. else
  7986. mddev->recovery_cp =
  7987. mddev->curr_resync;
  7988. }
  7989. } else
  7990. mddev->recovery_cp = MaxSector;
  7991. } else {
  7992. if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
  7993. mddev->curr_resync = MaxSector;
  7994. if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
  7995. test_bit(MD_RECOVERY_RECOVER, &mddev->recovery)) {
  7996. rcu_read_lock();
  7997. rdev_for_each_rcu(rdev, mddev)
  7998. if (rdev->raid_disk >= 0 &&
  7999. mddev->delta_disks >= 0 &&
  8000. !test_bit(Journal, &rdev->flags) &&
  8001. !test_bit(Faulty, &rdev->flags) &&
  8002. !test_bit(In_sync, &rdev->flags) &&
  8003. rdev->recovery_offset < mddev->curr_resync)
  8004. rdev->recovery_offset = mddev->curr_resync;
  8005. rcu_read_unlock();
  8006. }
  8007. }
  8008. }
  8009. skip:
  8010. /* set CHANGE_PENDING here since maybe another update is needed,
  8011. * so other nodes are informed. It should be harmless for normal
  8012. * raid */
  8013. set_mask_bits(&mddev->sb_flags, 0,
  8014. BIT(MD_SB_CHANGE_PENDING) | BIT(MD_SB_CHANGE_DEVS));
  8015. if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
  8016. !test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
  8017. mddev->delta_disks > 0 &&
  8018. mddev->pers->finish_reshape &&
  8019. mddev->pers->size &&
  8020. mddev->queue) {
  8021. mddev_lock_nointr(mddev);
  8022. md_set_array_sectors(mddev, mddev->pers->size(mddev, 0, 0));
  8023. mddev_unlock(mddev);
  8024. if (!mddev_is_clustered(mddev)) {
  8025. set_capacity(mddev->gendisk, mddev->array_sectors);
  8026. revalidate_disk_size(mddev->gendisk, true);
  8027. }
  8028. }
  8029. spin_lock(&mddev->lock);
  8030. if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
  8031. /* We completed so min/max setting can be forgotten if used. */
  8032. if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
  8033. mddev->resync_min = 0;
  8034. mddev->resync_max = MaxSector;
  8035. } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
  8036. mddev->resync_min = mddev->curr_resync_completed;
  8037. set_bit(MD_RECOVERY_DONE, &mddev->recovery);
  8038. mddev->curr_resync = 0;
  8039. spin_unlock(&mddev->lock);
  8040. wake_up(&resync_wait);
  8041. md_wakeup_thread(mddev->thread);
  8042. return;
  8043. }
  8044. EXPORT_SYMBOL_GPL(md_do_sync);
  8045. static int remove_and_add_spares(struct mddev *mddev,
  8046. struct md_rdev *this)
  8047. {
  8048. struct md_rdev *rdev;
  8049. int spares = 0;
  8050. int removed = 0;
  8051. bool remove_some = false;
  8052. if (this && test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
  8053. /* Mustn't remove devices when resync thread is running */
  8054. return 0;
  8055. rdev_for_each(rdev, mddev) {
  8056. if ((this == NULL || rdev == this) &&
  8057. rdev->raid_disk >= 0 &&
  8058. !test_bit(Blocked, &rdev->flags) &&
  8059. test_bit(Faulty, &rdev->flags) &&
  8060. atomic_read(&rdev->nr_pending)==0) {
  8061. /* Faulty non-Blocked devices with nr_pending == 0
  8062. * never get nr_pending incremented,
  8063. * never get Faulty cleared, and never get Blocked set.
  8064. * So we can synchronize_rcu now rather than once per device
  8065. */
  8066. remove_some = true;
  8067. set_bit(RemoveSynchronized, &rdev->flags);
  8068. }
  8069. }
  8070. if (remove_some)
  8071. synchronize_rcu();
  8072. rdev_for_each(rdev, mddev) {
  8073. if ((this == NULL || rdev == this) &&
  8074. rdev->raid_disk >= 0 &&
  8075. !test_bit(Blocked, &rdev->flags) &&
  8076. ((test_bit(RemoveSynchronized, &rdev->flags) ||
  8077. (!test_bit(In_sync, &rdev->flags) &&
  8078. !test_bit(Journal, &rdev->flags))) &&
  8079. atomic_read(&rdev->nr_pending)==0)) {
  8080. if (mddev->pers->hot_remove_disk(
  8081. mddev, rdev) == 0) {
  8082. sysfs_unlink_rdev(mddev, rdev);
  8083. rdev->saved_raid_disk = rdev->raid_disk;
  8084. rdev->raid_disk = -1;
  8085. removed++;
  8086. }
  8087. }
  8088. if (remove_some && test_bit(RemoveSynchronized, &rdev->flags))
  8089. clear_bit(RemoveSynchronized, &rdev->flags);
  8090. }
  8091. if (removed && mddev->kobj.sd)
  8092. sysfs_notify_dirent_safe(mddev->sysfs_degraded);
  8093. if (this && removed)
  8094. goto no_add;
  8095. rdev_for_each(rdev, mddev) {
  8096. if (this && this != rdev)
  8097. continue;
  8098. if (test_bit(Candidate, &rdev->flags))
  8099. continue;
  8100. if (rdev->raid_disk >= 0 &&
  8101. !test_bit(In_sync, &rdev->flags) &&
  8102. !test_bit(Journal, &rdev->flags) &&
  8103. !test_bit(Faulty, &rdev->flags))
  8104. spares++;
  8105. if (rdev->raid_disk >= 0)
  8106. continue;
  8107. if (test_bit(Faulty, &rdev->flags))
  8108. continue;
  8109. if (!test_bit(Journal, &rdev->flags)) {
  8110. if (mddev->ro &&
  8111. ! (rdev->saved_raid_disk >= 0 &&
  8112. !test_bit(Bitmap_sync, &rdev->flags)))
  8113. continue;
  8114. rdev->recovery_offset = 0;
  8115. }
  8116. if (mddev->pers->hot_add_disk(mddev, rdev) == 0) {
  8117. /* failure here is OK */
  8118. sysfs_link_rdev(mddev, rdev);
  8119. if (!test_bit(Journal, &rdev->flags))
  8120. spares++;
  8121. md_new_event(mddev);
  8122. set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
  8123. }
  8124. }
  8125. no_add:
  8126. if (removed)
  8127. set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
  8128. return spares;
  8129. }
  8130. static void md_start_sync(struct work_struct *ws)
  8131. {
  8132. struct mddev *mddev = container_of(ws, struct mddev, del_work);
  8133. mddev->sync_thread = md_register_thread(md_do_sync,
  8134. mddev,
  8135. "resync");
  8136. if (!mddev->sync_thread) {
  8137. pr_warn("%s: could not start resync thread...\n",
  8138. mdname(mddev));
  8139. /* leave the spares where they are, it shouldn't hurt */
  8140. clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
  8141. clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
  8142. clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
  8143. clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
  8144. clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
  8145. wake_up(&resync_wait);
  8146. if (test_and_clear_bit(MD_RECOVERY_RECOVER,
  8147. &mddev->recovery))
  8148. if (mddev->sysfs_action)
  8149. sysfs_notify_dirent_safe(mddev->sysfs_action);
  8150. } else
  8151. md_wakeup_thread(mddev->sync_thread);
  8152. sysfs_notify_dirent_safe(mddev->sysfs_action);
  8153. md_new_event(mddev);
  8154. }
  8155. /*
  8156. * This routine is regularly called by all per-raid-array threads to
  8157. * deal with generic issues like resync and super-block update.
  8158. * Raid personalities that don't have a thread (linear/raid0) do not
  8159. * need this as they never do any recovery or update the superblock.
  8160. *
  8161. * It does not do any resync itself, but rather "forks" off other threads
  8162. * to do that as needed.
  8163. * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in
  8164. * "->recovery" and create a thread at ->sync_thread.
  8165. * When the thread finishes it sets MD_RECOVERY_DONE
  8166. * and wakeups up this thread which will reap the thread and finish up.
  8167. * This thread also removes any faulty devices (with nr_pending == 0).
  8168. *
  8169. * The overall approach is:
  8170. * 1/ if the superblock needs updating, update it.
  8171. * 2/ If a recovery thread is running, don't do anything else.
  8172. * 3/ If recovery has finished, clean up, possibly marking spares active.
  8173. * 4/ If there are any faulty devices, remove them.
  8174. * 5/ If array is degraded, try to add spares devices
  8175. * 6/ If array has spares or is not in-sync, start a resync thread.
  8176. */
  8177. void md_check_recovery(struct mddev *mddev)
  8178. {
  8179. if (test_bit(MD_ALLOW_SB_UPDATE, &mddev->flags) && mddev->sb_flags) {
  8180. /* Write superblock - thread that called mddev_suspend()
  8181. * holds reconfig_mutex for us.
  8182. */
  8183. set_bit(MD_UPDATING_SB, &mddev->flags);
  8184. smp_mb__after_atomic();
  8185. if (test_bit(MD_ALLOW_SB_UPDATE, &mddev->flags))
  8186. md_update_sb(mddev, 0);
  8187. clear_bit_unlock(MD_UPDATING_SB, &mddev->flags);
  8188. wake_up(&mddev->sb_wait);
  8189. }
  8190. if (mddev->suspended)
  8191. return;
  8192. if (mddev->bitmap)
  8193. md_bitmap_daemon_work(mddev);
  8194. if (signal_pending(current)) {
  8195. if (mddev->pers->sync_request && !mddev->external) {
  8196. pr_debug("md: %s in immediate safe mode\n",
  8197. mdname(mddev));
  8198. mddev->safemode = 2;
  8199. }
  8200. flush_signals(current);
  8201. }
  8202. if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
  8203. return;
  8204. if ( ! (
  8205. (mddev->sb_flags & ~ (1<<MD_SB_CHANGE_PENDING)) ||
  8206. test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
  8207. test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
  8208. (mddev->external == 0 && mddev->safemode == 1) ||
  8209. (mddev->safemode == 2
  8210. && !mddev->in_sync && mddev->recovery_cp == MaxSector)
  8211. ))
  8212. return;
  8213. if (mddev_trylock(mddev)) {
  8214. int spares = 0;
  8215. bool try_set_sync = mddev->safemode != 0;
  8216. if (!mddev->external && mddev->safemode == 1)
  8217. mddev->safemode = 0;
  8218. if (mddev->ro) {
  8219. struct md_rdev *rdev;
  8220. if (!mddev->external && mddev->in_sync)
  8221. /* 'Blocked' flag not needed as failed devices
  8222. * will be recorded if array switched to read/write.
  8223. * Leaving it set will prevent the device
  8224. * from being removed.
  8225. */
  8226. rdev_for_each(rdev, mddev)
  8227. clear_bit(Blocked, &rdev->flags);
  8228. /* On a read-only array we can:
  8229. * - remove failed devices
  8230. * - add already-in_sync devices if the array itself
  8231. * is in-sync.
  8232. * As we only add devices that are already in-sync,
  8233. * we can activate the spares immediately.
  8234. */
  8235. remove_and_add_spares(mddev, NULL);
  8236. /* There is no thread, but we need to call
  8237. * ->spare_active and clear saved_raid_disk
  8238. */
  8239. set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  8240. md_reap_sync_thread(mddev);
  8241. clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
  8242. clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  8243. clear_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags);
  8244. goto unlock;
  8245. }
  8246. if (mddev_is_clustered(mddev)) {
  8247. struct md_rdev *rdev, *tmp;
  8248. /* kick the device if another node issued a
  8249. * remove disk.
  8250. */
  8251. rdev_for_each_safe(rdev, tmp, mddev) {
  8252. if (test_and_clear_bit(ClusterRemove, &rdev->flags) &&
  8253. rdev->raid_disk < 0)
  8254. md_kick_rdev_from_array(rdev);
  8255. }
  8256. }
  8257. if (try_set_sync && !mddev->external && !mddev->in_sync) {
  8258. spin_lock(&mddev->lock);
  8259. set_in_sync(mddev);
  8260. spin_unlock(&mddev->lock);
  8261. }
  8262. if (mddev->sb_flags)
  8263. md_update_sb(mddev, 0);
  8264. if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
  8265. !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
  8266. /* resync/recovery still happening */
  8267. clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  8268. goto unlock;
  8269. }
  8270. if (mddev->sync_thread) {
  8271. md_reap_sync_thread(mddev);
  8272. goto unlock;
  8273. }
  8274. /* Set RUNNING before clearing NEEDED to avoid
  8275. * any transients in the value of "sync_action".
  8276. */
  8277. mddev->curr_resync_completed = 0;
  8278. spin_lock(&mddev->lock);
  8279. set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
  8280. spin_unlock(&mddev->lock);
  8281. /* Clear some bits that don't mean anything, but
  8282. * might be left set
  8283. */
  8284. clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
  8285. clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
  8286. if (!test_and_clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
  8287. test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
  8288. goto not_running;
  8289. /* no recovery is running.
  8290. * remove any failed drives, then
  8291. * add spares if possible.
  8292. * Spares are also removed and re-added, to allow
  8293. * the personality to fail the re-add.
  8294. */
  8295. if (mddev->reshape_position != MaxSector) {
  8296. if (mddev->pers->check_reshape == NULL ||
  8297. mddev->pers->check_reshape(mddev) != 0)
  8298. /* Cannot proceed */
  8299. goto not_running;
  8300. set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
  8301. clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
  8302. } else if ((spares = remove_and_add_spares(mddev, NULL))) {
  8303. clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
  8304. clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
  8305. clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
  8306. set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
  8307. } else if (mddev->recovery_cp < MaxSector) {
  8308. set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
  8309. clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
  8310. } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
  8311. /* nothing to be done ... */
  8312. goto not_running;
  8313. if (mddev->pers->sync_request) {
  8314. if (spares) {
  8315. /* We are adding a device or devices to an array
  8316. * which has the bitmap stored on all devices.
  8317. * So make sure all bitmap pages get written
  8318. */
  8319. md_bitmap_write_all(mddev->bitmap);
  8320. }
  8321. INIT_WORK(&mddev->del_work, md_start_sync);
  8322. queue_work(md_misc_wq, &mddev->del_work);
  8323. goto unlock;
  8324. }
  8325. not_running:
  8326. if (!mddev->sync_thread) {
  8327. clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
  8328. wake_up(&resync_wait);
  8329. if (test_and_clear_bit(MD_RECOVERY_RECOVER,
  8330. &mddev->recovery))
  8331. if (mddev->sysfs_action)
  8332. sysfs_notify_dirent_safe(mddev->sysfs_action);
  8333. }
  8334. unlock:
  8335. wake_up(&mddev->sb_wait);
  8336. mddev_unlock(mddev);
  8337. }
  8338. }
  8339. EXPORT_SYMBOL(md_check_recovery);
  8340. void md_reap_sync_thread(struct mddev *mddev)
  8341. {
  8342. struct md_rdev *rdev;
  8343. sector_t old_dev_sectors = mddev->dev_sectors;
  8344. bool is_reshaped = false;
  8345. /* resync has finished, collect result */
  8346. md_unregister_thread(&mddev->sync_thread);
  8347. if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
  8348. !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery) &&
  8349. mddev->degraded != mddev->raid_disks) {
  8350. /* success...*/
  8351. /* activate any spares */
  8352. if (mddev->pers->spare_active(mddev)) {
  8353. sysfs_notify_dirent_safe(mddev->sysfs_degraded);
  8354. set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
  8355. }
  8356. }
  8357. if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
  8358. mddev->pers->finish_reshape) {
  8359. mddev->pers->finish_reshape(mddev);
  8360. if (mddev_is_clustered(mddev))
  8361. is_reshaped = true;
  8362. }
  8363. /* If array is no-longer degraded, then any saved_raid_disk
  8364. * information must be scrapped.
  8365. */
  8366. if (!mddev->degraded)
  8367. rdev_for_each(rdev, mddev)
  8368. rdev->saved_raid_disk = -1;
  8369. md_update_sb(mddev, 1);
  8370. /* MD_SB_CHANGE_PENDING should be cleared by md_update_sb, so we can
  8371. * call resync_finish here if MD_CLUSTER_RESYNC_LOCKED is set by
  8372. * clustered raid */
  8373. if (test_and_clear_bit(MD_CLUSTER_RESYNC_LOCKED, &mddev->flags))
  8374. md_cluster_ops->resync_finish(mddev);
  8375. clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
  8376. clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
  8377. clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
  8378. clear_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
  8379. clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
  8380. clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
  8381. /*
  8382. * We call md_cluster_ops->update_size here because sync_size could
  8383. * be changed by md_update_sb, and MD_RECOVERY_RESHAPE is cleared,
  8384. * so it is time to update size across cluster.
  8385. */
  8386. if (mddev_is_clustered(mddev) && is_reshaped
  8387. && !test_bit(MD_CLOSING, &mddev->flags))
  8388. md_cluster_ops->update_size(mddev, old_dev_sectors);
  8389. wake_up(&resync_wait);
  8390. /* flag recovery needed just to double check */
  8391. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  8392. sysfs_notify_dirent_safe(mddev->sysfs_action);
  8393. md_new_event(mddev);
  8394. if (mddev->event_work.func)
  8395. queue_work(md_misc_wq, &mddev->event_work);
  8396. }
  8397. EXPORT_SYMBOL(md_reap_sync_thread);
  8398. void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev)
  8399. {
  8400. sysfs_notify_dirent_safe(rdev->sysfs_state);
  8401. wait_event_timeout(rdev->blocked_wait,
  8402. !test_bit(Blocked, &rdev->flags) &&
  8403. !test_bit(BlockedBadBlocks, &rdev->flags),
  8404. msecs_to_jiffies(5000));
  8405. rdev_dec_pending(rdev, mddev);
  8406. }
  8407. EXPORT_SYMBOL(md_wait_for_blocked_rdev);
  8408. void md_finish_reshape(struct mddev *mddev)
  8409. {
  8410. /* called be personality module when reshape completes. */
  8411. struct md_rdev *rdev;
  8412. rdev_for_each(rdev, mddev) {
  8413. if (rdev->data_offset > rdev->new_data_offset)
  8414. rdev->sectors += rdev->data_offset - rdev->new_data_offset;
  8415. else
  8416. rdev->sectors -= rdev->new_data_offset - rdev->data_offset;
  8417. rdev->data_offset = rdev->new_data_offset;
  8418. }
  8419. }
  8420. EXPORT_SYMBOL(md_finish_reshape);
  8421. /* Bad block management */
  8422. /* Returns 1 on success, 0 on failure */
  8423. int rdev_set_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
  8424. int is_new)
  8425. {
  8426. struct mddev *mddev = rdev->mddev;
  8427. int rv;
  8428. if (is_new)
  8429. s += rdev->new_data_offset;
  8430. else
  8431. s += rdev->data_offset;
  8432. rv = badblocks_set(&rdev->badblocks, s, sectors, 0);
  8433. if (rv == 0) {
  8434. /* Make sure they get written out promptly */
  8435. if (test_bit(ExternalBbl, &rdev->flags))
  8436. sysfs_notify_dirent_safe(rdev->sysfs_unack_badblocks);
  8437. sysfs_notify_dirent_safe(rdev->sysfs_state);
  8438. set_mask_bits(&mddev->sb_flags, 0,
  8439. BIT(MD_SB_CHANGE_CLEAN) | BIT(MD_SB_CHANGE_PENDING));
  8440. md_wakeup_thread(rdev->mddev->thread);
  8441. return 1;
  8442. } else
  8443. return 0;
  8444. }
  8445. EXPORT_SYMBOL_GPL(rdev_set_badblocks);
  8446. int rdev_clear_badblocks(struct md_rdev *rdev, sector_t s, int sectors,
  8447. int is_new)
  8448. {
  8449. int rv;
  8450. if (is_new)
  8451. s += rdev->new_data_offset;
  8452. else
  8453. s += rdev->data_offset;
  8454. rv = badblocks_clear(&rdev->badblocks, s, sectors);
  8455. if ((rv == 0) && test_bit(ExternalBbl, &rdev->flags))
  8456. sysfs_notify_dirent_safe(rdev->sysfs_badblocks);
  8457. return rv;
  8458. }
  8459. EXPORT_SYMBOL_GPL(rdev_clear_badblocks);
  8460. static int md_notify_reboot(struct notifier_block *this,
  8461. unsigned long code, void *x)
  8462. {
  8463. struct list_head *tmp;
  8464. struct mddev *mddev;
  8465. int need_delay = 0;
  8466. for_each_mddev(mddev, tmp) {
  8467. if (mddev_trylock(mddev)) {
  8468. if (mddev->pers)
  8469. __md_stop_writes(mddev);
  8470. if (mddev->persistent)
  8471. mddev->safemode = 2;
  8472. mddev_unlock(mddev);
  8473. }
  8474. need_delay = 1;
  8475. }
  8476. /*
  8477. * certain more exotic SCSI devices are known to be
  8478. * volatile wrt too early system reboots. While the
  8479. * right place to handle this issue is the given
  8480. * driver, we do want to have a safe RAID driver ...
  8481. */
  8482. if (need_delay)
  8483. mdelay(1000*1);
  8484. return NOTIFY_DONE;
  8485. }
  8486. static struct notifier_block md_notifier = {
  8487. .notifier_call = md_notify_reboot,
  8488. .next = NULL,
  8489. .priority = INT_MAX, /* before any real devices */
  8490. };
  8491. static void md_geninit(void)
  8492. {
  8493. pr_debug("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
  8494. proc_create("mdstat", S_IRUGO, NULL, &mdstat_proc_ops);
  8495. }
  8496. static int __init md_init(void)
  8497. {
  8498. int ret = -ENOMEM;
  8499. md_wq = alloc_workqueue("md", WQ_MEM_RECLAIM, 0);
  8500. if (!md_wq)
  8501. goto err_wq;
  8502. md_misc_wq = alloc_workqueue("md_misc", 0, 0);
  8503. if (!md_misc_wq)
  8504. goto err_misc_wq;
  8505. md_rdev_misc_wq = alloc_workqueue("md_rdev_misc", 0, 0);
  8506. if (!md_rdev_misc_wq)
  8507. goto err_rdev_misc_wq;
  8508. if ((ret = register_blkdev(MD_MAJOR, "md")) < 0)
  8509. goto err_md;
  8510. if ((ret = register_blkdev(0, "mdp")) < 0)
  8511. goto err_mdp;
  8512. mdp_major = ret;
  8513. blk_register_region(MKDEV(MD_MAJOR, 0), 512, THIS_MODULE,
  8514. md_probe, NULL, NULL);
  8515. blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE,
  8516. md_probe, NULL, NULL);
  8517. register_reboot_notifier(&md_notifier);
  8518. raid_table_header = register_sysctl_table(raid_root_table);
  8519. md_geninit();
  8520. return 0;
  8521. err_mdp:
  8522. unregister_blkdev(MD_MAJOR, "md");
  8523. err_md:
  8524. destroy_workqueue(md_rdev_misc_wq);
  8525. err_rdev_misc_wq:
  8526. destroy_workqueue(md_misc_wq);
  8527. err_misc_wq:
  8528. destroy_workqueue(md_wq);
  8529. err_wq:
  8530. return ret;
  8531. }
  8532. static void check_sb_changes(struct mddev *mddev, struct md_rdev *rdev)
  8533. {
  8534. struct mdp_superblock_1 *sb = page_address(rdev->sb_page);
  8535. struct md_rdev *rdev2, *tmp;
  8536. int role, ret;
  8537. char b[BDEVNAME_SIZE];
  8538. /*
  8539. * If size is changed in another node then we need to
  8540. * do resize as well.
  8541. */
  8542. if (mddev->dev_sectors != le64_to_cpu(sb->size)) {
  8543. ret = mddev->pers->resize(mddev, le64_to_cpu(sb->size));
  8544. if (ret)
  8545. pr_info("md-cluster: resize failed\n");
  8546. else
  8547. md_bitmap_update_sb(mddev->bitmap);
  8548. }
  8549. /* Check for change of roles in the active devices */
  8550. rdev_for_each_safe(rdev2, tmp, mddev) {
  8551. if (test_bit(Faulty, &rdev2->flags))
  8552. continue;
  8553. /* Check if the roles changed */
  8554. role = le16_to_cpu(sb->dev_roles[rdev2->desc_nr]);
  8555. if (test_bit(Candidate, &rdev2->flags)) {
  8556. if (role == 0xfffe) {
  8557. pr_info("md: Removing Candidate device %s because add failed\n", bdevname(rdev2->bdev,b));
  8558. md_kick_rdev_from_array(rdev2);
  8559. continue;
  8560. }
  8561. else
  8562. clear_bit(Candidate, &rdev2->flags);
  8563. }
  8564. if (role != rdev2->raid_disk) {
  8565. /*
  8566. * got activated except reshape is happening.
  8567. */
  8568. if (rdev2->raid_disk == -1 && role != 0xffff &&
  8569. !(le32_to_cpu(sb->feature_map) &
  8570. MD_FEATURE_RESHAPE_ACTIVE)) {
  8571. rdev2->saved_raid_disk = role;
  8572. ret = remove_and_add_spares(mddev, rdev2);
  8573. pr_info("Activated spare: %s\n",
  8574. bdevname(rdev2->bdev,b));
  8575. /* wakeup mddev->thread here, so array could
  8576. * perform resync with the new activated disk */
  8577. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  8578. md_wakeup_thread(mddev->thread);
  8579. }
  8580. /* device faulty
  8581. * We just want to do the minimum to mark the disk
  8582. * as faulty. The recovery is performed by the
  8583. * one who initiated the error.
  8584. */
  8585. if ((role == 0xfffe) || (role == 0xfffd)) {
  8586. md_error(mddev, rdev2);
  8587. clear_bit(Blocked, &rdev2->flags);
  8588. }
  8589. }
  8590. }
  8591. if (mddev->raid_disks != le32_to_cpu(sb->raid_disks)) {
  8592. ret = update_raid_disks(mddev, le32_to_cpu(sb->raid_disks));
  8593. if (ret)
  8594. pr_warn("md: updating array disks failed. %d\n", ret);
  8595. }
  8596. /*
  8597. * Since mddev->delta_disks has already updated in update_raid_disks,
  8598. * so it is time to check reshape.
  8599. */
  8600. if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) &&
  8601. (le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
  8602. /*
  8603. * reshape is happening in the remote node, we need to
  8604. * update reshape_position and call start_reshape.
  8605. */
  8606. mddev->reshape_position = le64_to_cpu(sb->reshape_position);
  8607. if (mddev->pers->update_reshape_pos)
  8608. mddev->pers->update_reshape_pos(mddev);
  8609. if (mddev->pers->start_reshape)
  8610. mddev->pers->start_reshape(mddev);
  8611. } else if (test_bit(MD_RESYNCING_REMOTE, &mddev->recovery) &&
  8612. mddev->reshape_position != MaxSector &&
  8613. !(le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
  8614. /* reshape is just done in another node. */
  8615. mddev->reshape_position = MaxSector;
  8616. if (mddev->pers->update_reshape_pos)
  8617. mddev->pers->update_reshape_pos(mddev);
  8618. }
  8619. /* Finally set the event to be up to date */
  8620. mddev->events = le64_to_cpu(sb->events);
  8621. }
  8622. static int read_rdev(struct mddev *mddev, struct md_rdev *rdev)
  8623. {
  8624. int err;
  8625. struct page *swapout = rdev->sb_page;
  8626. struct mdp_superblock_1 *sb;
  8627. /* Store the sb page of the rdev in the swapout temporary
  8628. * variable in case we err in the future
  8629. */
  8630. rdev->sb_page = NULL;
  8631. err = alloc_disk_sb(rdev);
  8632. if (err == 0) {
  8633. ClearPageUptodate(rdev->sb_page);
  8634. rdev->sb_loaded = 0;
  8635. err = super_types[mddev->major_version].
  8636. load_super(rdev, NULL, mddev->minor_version);
  8637. }
  8638. if (err < 0) {
  8639. pr_warn("%s: %d Could not reload rdev(%d) err: %d. Restoring old values\n",
  8640. __func__, __LINE__, rdev->desc_nr, err);
  8641. if (rdev->sb_page)
  8642. put_page(rdev->sb_page);
  8643. rdev->sb_page = swapout;
  8644. rdev->sb_loaded = 1;
  8645. return err;
  8646. }
  8647. sb = page_address(rdev->sb_page);
  8648. /* Read the offset unconditionally, even if MD_FEATURE_RECOVERY_OFFSET
  8649. * is not set
  8650. */
  8651. if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RECOVERY_OFFSET))
  8652. rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
  8653. /* The other node finished recovery, call spare_active to set
  8654. * device In_sync and mddev->degraded
  8655. */
  8656. if (rdev->recovery_offset == MaxSector &&
  8657. !test_bit(In_sync, &rdev->flags) &&
  8658. mddev->pers->spare_active(mddev))
  8659. sysfs_notify_dirent_safe(mddev->sysfs_degraded);
  8660. put_page(swapout);
  8661. return 0;
  8662. }
  8663. void md_reload_sb(struct mddev *mddev, int nr)
  8664. {
  8665. struct md_rdev *rdev;
  8666. int err;
  8667. /* Find the rdev */
  8668. rdev_for_each_rcu(rdev, mddev) {
  8669. if (rdev->desc_nr == nr)
  8670. break;
  8671. }
  8672. if (!rdev || rdev->desc_nr != nr) {
  8673. pr_warn("%s: %d Could not find rdev with nr %d\n", __func__, __LINE__, nr);
  8674. return;
  8675. }
  8676. err = read_rdev(mddev, rdev);
  8677. if (err < 0)
  8678. return;
  8679. check_sb_changes(mddev, rdev);
  8680. /* Read all rdev's to update recovery_offset */
  8681. rdev_for_each_rcu(rdev, mddev) {
  8682. if (!test_bit(Faulty, &rdev->flags))
  8683. read_rdev(mddev, rdev);
  8684. }
  8685. }
  8686. EXPORT_SYMBOL(md_reload_sb);
  8687. #ifndef MODULE
  8688. /*
  8689. * Searches all registered partitions for autorun RAID arrays
  8690. * at boot time.
  8691. */
  8692. static DEFINE_MUTEX(detected_devices_mutex);
  8693. static LIST_HEAD(all_detected_devices);
  8694. struct detected_devices_node {
  8695. struct list_head list;
  8696. dev_t dev;
  8697. };
  8698. void md_autodetect_dev(dev_t dev)
  8699. {
  8700. struct detected_devices_node *node_detected_dev;
  8701. node_detected_dev = kzalloc(sizeof(*node_detected_dev), GFP_KERNEL);
  8702. if (node_detected_dev) {
  8703. node_detected_dev->dev = dev;
  8704. mutex_lock(&detected_devices_mutex);
  8705. list_add_tail(&node_detected_dev->list, &all_detected_devices);
  8706. mutex_unlock(&detected_devices_mutex);
  8707. }
  8708. }
  8709. void md_autostart_arrays(int part)
  8710. {
  8711. struct md_rdev *rdev;
  8712. struct detected_devices_node *node_detected_dev;
  8713. dev_t dev;
  8714. int i_scanned, i_passed;
  8715. i_scanned = 0;
  8716. i_passed = 0;
  8717. pr_info("md: Autodetecting RAID arrays.\n");
  8718. mutex_lock(&detected_devices_mutex);
  8719. while (!list_empty(&all_detected_devices) && i_scanned < INT_MAX) {
  8720. i_scanned++;
  8721. node_detected_dev = list_entry(all_detected_devices.next,
  8722. struct detected_devices_node, list);
  8723. list_del(&node_detected_dev->list);
  8724. dev = node_detected_dev->dev;
  8725. kfree(node_detected_dev);
  8726. mutex_unlock(&detected_devices_mutex);
  8727. rdev = md_import_device(dev,0, 90);
  8728. mutex_lock(&detected_devices_mutex);
  8729. if (IS_ERR(rdev))
  8730. continue;
  8731. if (test_bit(Faulty, &rdev->flags))
  8732. continue;
  8733. set_bit(AutoDetected, &rdev->flags);
  8734. list_add(&rdev->same_set, &pending_raid_disks);
  8735. i_passed++;
  8736. }
  8737. mutex_unlock(&detected_devices_mutex);
  8738. pr_debug("md: Scanned %d and added %d devices.\n", i_scanned, i_passed);
  8739. autorun_devices(part);
  8740. }
  8741. #endif /* !MODULE */
  8742. static __exit void md_exit(void)
  8743. {
  8744. struct mddev *mddev;
  8745. struct list_head *tmp;
  8746. int delay = 1;
  8747. blk_unregister_region(MKDEV(MD_MAJOR,0), 512);
  8748. blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS);
  8749. unregister_blkdev(MD_MAJOR,"md");
  8750. unregister_blkdev(mdp_major, "mdp");
  8751. unregister_reboot_notifier(&md_notifier);
  8752. unregister_sysctl_table(raid_table_header);
  8753. /* We cannot unload the modules while some process is
  8754. * waiting for us in select() or poll() - wake them up
  8755. */
  8756. md_unloading = 1;
  8757. while (waitqueue_active(&md_event_waiters)) {
  8758. /* not safe to leave yet */
  8759. wake_up(&md_event_waiters);
  8760. msleep(delay);
  8761. delay += delay;
  8762. }
  8763. remove_proc_entry("mdstat", NULL);
  8764. for_each_mddev(mddev, tmp) {
  8765. export_array(mddev);
  8766. mddev->ctime = 0;
  8767. mddev->hold_active = 0;
  8768. /*
  8769. * for_each_mddev() will call mddev_put() at the end of each
  8770. * iteration. As the mddev is now fully clear, this will
  8771. * schedule the mddev for destruction by a workqueue, and the
  8772. * destroy_workqueue() below will wait for that to complete.
  8773. */
  8774. }
  8775. destroy_workqueue(md_rdev_misc_wq);
  8776. destroy_workqueue(md_misc_wq);
  8777. destroy_workqueue(md_wq);
  8778. }
  8779. subsys_initcall(md_init);
  8780. module_exit(md_exit)
  8781. static int get_ro(char *buffer, const struct kernel_param *kp)
  8782. {
  8783. return sprintf(buffer, "%d\n", start_readonly);
  8784. }
  8785. static int set_ro(const char *val, const struct kernel_param *kp)
  8786. {
  8787. return kstrtouint(val, 10, (unsigned int *)&start_readonly);
  8788. }
  8789. module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR);
  8790. module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR);
  8791. module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR);
  8792. module_param(create_on_open, bool, S_IRUSR|S_IWUSR);
  8793. MODULE_LICENSE("GPL");
  8794. MODULE_DESCRIPTION("MD RAID framework");
  8795. MODULE_ALIAS("md");
  8796. MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);