md.c 190 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508450945104511451245134514451545164517451845194520452145224523452445254526452745284529453045314532453345344535453645374538453945404541454245434544454545464547454845494550455145524553455445554556455745584559456045614562456345644565456645674568456945704571457245734574457545764577457845794580458145824583458445854586458745884589459045914592459345944595459645974598459946004601460246034604460546064607460846094610461146124613461446154616461746184619462046214622462346244625462646274628462946304631463246334634463546364637463846394640464146424643464446454646464746484649465046514652465346544655465646574658465946604661466246634664466546664667466846694670467146724673467446754676467746784679468046814682468346844685468646874688468946904691469246934694469546964697469846994700470147024703470447054706470747084709471047114712471347144715471647174718471947204721472247234724472547264727472847294730473147324733473447354736473747384739474047414742474347444745474647474748474947504751475247534754475547564757475847594760476147624763476447654766476747684769477047714772477347744775477647774778477947804781478247834784478547864787478847894790479147924793479447954796479747984799480048014802480348044805480648074808480948104811481248134814481548164817481848194820482148224823482448254826482748284829483048314832483348344835483648374838483948404841484248434844484548464847484848494850485148524853485448554856485748584859486048614862486348644865486648674868486948704871487248734874487548764877487848794880488148824883488448854886488748884889489048914892489348944895489648974898489949004901490249034904490549064907490849094910491149124913491449154916491749184919492049214922492349244925492649274928492949304931493249334934493549364937493849394940494149424943494449454946494749484949495049514952495349544955495649574958495949604961496249634964496549664967496849694970497149724973497449754976497749784979498049814982498349844985498649874988498949904991499249934994499549964997499849995000500150025003500450055006500750085009501050115012501350145015501650175018501950205021502250235024502550265027502850295030503150325033503450355036503750385039504050415042504350445045504650475048504950505051505250535054505550565057505850595060506150625063506450655066506750685069507050715072507350745075507650775078507950805081508250835084508550865087508850895090509150925093509450955096509750985099510051015102510351045105510651075108510951105111511251135114511551165117511851195120512151225123512451255126512751285129513051315132513351345135513651375138513951405141514251435144514551465147514851495150515151525153515451555156515751585159516051615162516351645165516651675168516951705171517251735174517551765177517851795180518151825183518451855186518751885189519051915192519351945195519651975198519952005201520252035204520552065207520852095210521152125213521452155216521752185219522052215222522352245225522652275228522952305231523252335234523552365237523852395240524152425243524452455246524752485249525052515252525352545255525652575258525952605261526252635264526552665267526852695270527152725273527452755276527752785279528052815282528352845285528652875288528952905291529252935294529552965297529852995300530153025303530453055306530753085309531053115312531353145315531653175318531953205321532253235324532553265327532853295330533153325333533453355336533753385339534053415342534353445345534653475348534953505351535253535354535553565357535853595360536153625363536453655366536753685369537053715372537353745375537653775378537953805381538253835384538553865387538853895390539153925393539453955396539753985399540054015402540354045405540654075408540954105411541254135414541554165417541854195420542154225423542454255426542754285429543054315432543354345435543654375438543954405441544254435444544554465447544854495450545154525453545454555456545754585459546054615462546354645465546654675468546954705471547254735474547554765477547854795480548154825483548454855486548754885489549054915492549354945495549654975498549955005501550255035504550555065507550855095510551155125513551455155516551755185519552055215522552355245525552655275528552955305531553255335534553555365537553855395540554155425543554455455546554755485549555055515552555355545555555655575558555955605561556255635564556555665567556855695570557155725573557455755576557755785579558055815582558355845585558655875588558955905591559255935594559555965597559855995600560156025603560456055606560756085609561056115612561356145615561656175618561956205621562256235624562556265627562856295630563156325633563456355636563756385639564056415642564356445645564656475648564956505651565256535654565556565657565856595660566156625663566456655666566756685669567056715672567356745675567656775678567956805681568256835684568556865687568856895690569156925693569456955696569756985699570057015702570357045705570657075708570957105711571257135714571557165717571857195720572157225723572457255726572757285729573057315732573357345735573657375738573957405741574257435744574557465747574857495750575157525753575457555756575757585759576057615762576357645765576657675768576957705771577257735774577557765777577857795780578157825783578457855786578757885789579057915792579357945795579657975798579958005801580258035804580558065807580858095810581158125813581458155816581758185819582058215822582358245825582658275828582958305831583258335834583558365837583858395840584158425843584458455846584758485849585058515852585358545855585658575858585958605861586258635864586558665867586858695870587158725873587458755876587758785879588058815882588358845885588658875888588958905891589258935894589558965897589858995900590159025903590459055906590759085909591059115912591359145915591659175918591959205921592259235924592559265927592859295930593159325933593459355936593759385939594059415942594359445945594659475948594959505951595259535954595559565957595859595960596159625963596459655966596759685969597059715972597359745975597659775978597959805981598259835984598559865987598859895990599159925993599459955996599759985999600060016002600360046005600660076008600960106011601260136014601560166017601860196020602160226023602460256026602760286029603060316032603360346035603660376038603960406041604260436044604560466047604860496050605160526053605460556056605760586059606060616062606360646065606660676068606960706071607260736074607560766077607860796080608160826083608460856086608760886089609060916092609360946095609660976098609961006101610261036104610561066107610861096110611161126113611461156116611761186119612061216122612361246125612661276128612961306131613261336134613561366137613861396140614161426143614461456146614761486149615061516152615361546155615661576158615961606161616261636164616561666167616861696170617161726173617461756176617761786179618061816182618361846185618661876188618961906191619261936194619561966197619861996200620162026203620462056206620762086209621062116212621362146215621662176218621962206221622262236224622562266227622862296230623162326233623462356236623762386239624062416242624362446245624662476248624962506251625262536254625562566257625862596260626162626263626462656266626762686269627062716272627362746275627662776278627962806281628262836284628562866287628862896290629162926293629462956296629762986299630063016302630363046305630663076308630963106311631263136314631563166317631863196320632163226323632463256326632763286329633063316332633363346335633663376338633963406341634263436344634563466347634863496350635163526353635463556356635763586359636063616362636363646365636663676368636963706371637263736374637563766377637863796380638163826383638463856386638763886389639063916392639363946395639663976398639964006401640264036404640564066407640864096410641164126413641464156416641764186419642064216422642364246425642664276428642964306431643264336434643564366437643864396440644164426443644464456446644764486449645064516452645364546455645664576458645964606461646264636464646564666467646864696470647164726473647464756476647764786479648064816482648364846485648664876488648964906491649264936494649564966497649864996500650165026503650465056506650765086509651065116512651365146515651665176518651965206521652265236524652565266527652865296530653165326533653465356536653765386539654065416542654365446545654665476548654965506551655265536554655565566557655865596560656165626563656465656566656765686569657065716572657365746575657665776578657965806581658265836584658565866587658865896590659165926593659465956596659765986599660066016602660366046605660666076608660966106611661266136614661566166617661866196620662166226623662466256626662766286629663066316632663366346635663666376638663966406641664266436644664566466647664866496650665166526653665466556656665766586659666066616662666366646665666666676668666966706671667266736674667566766677667866796680668166826683668466856686668766886689669066916692669366946695669666976698669967006701670267036704670567066707670867096710671167126713671467156716671767186719672067216722672367246725672667276728672967306731673267336734673567366737673867396740674167426743674467456746674767486749675067516752675367546755675667576758675967606761676267636764676567666767676867696770677167726773677467756776677767786779678067816782678367846785678667876788678967906791679267936794679567966797679867996800680168026803680468056806680768086809681068116812681368146815681668176818681968206821682268236824682568266827682868296830683168326833683468356836683768386839684068416842684368446845684668476848684968506851685268536854685568566857685868596860686168626863686468656866686768686869687068716872687368746875687668776878687968806881688268836884688568866887688868896890689168926893689468956896689768986899690069016902690369046905690669076908690969106911691269136914691569166917691869196920692169226923692469256926692769286929693069316932693369346935693669376938693969406941694269436944694569466947694869496950695169526953695469556956695769586959696069616962696369646965696669676968696969706971697269736974697569766977697869796980698169826983698469856986698769886989699069916992699369946995699669976998699970007001700270037004700570067007700870097010701170127013701470157016701770187019702070217022702370247025702670277028702970307031703270337034703570367037703870397040704170427043704470457046704770487049705070517052705370547055705670577058705970607061706270637064706570667067706870697070707170727073707470757076707770787079708070817082708370847085708670877088708970907091709270937094709570967097709870997100710171027103710471057106710771087109711071117112711371147115711671177118711971207121712271237124712571267127712871297130713171327133713471357136713771387139714071417142714371447145714671477148714971507151715271537154715571567157715871597160716171627163716471657166716771687169717071717172717371747175717671777178717971807181718271837184718571867187718871897190719171927193719471957196719771987199720072017202720372047205720672077208720972107211721272137214721572167217721872197220722172227223722472257226722772287229723072317232723372347235723672377238723972407241724272437244724572467247724872497250725172527253725472557256725772587259726072617262726372647265726672677268726972707271727272737274727572767277727872797280728172827283728472857286728772887289729072917292729372947295729672977298729973007301730273037304730573067307730873097310731173127313731473157316731773187319732073217322732373247325732673277328732973307331733273337334733573367337733873397340734173427343734473457346734773487349735073517352735373547355735673577358735973607361736273637364736573667367736873697370737173727373737473757376737773787379738073817382738373847385738673877388738973907391739273937394739573967397739873997400740174027403740474057406740774087409741074117412741374147415741674177418741974207421
  1. /*
  2. md.c : Multiple Devices driver for Linux
  3. Copyright (C) 1998, 1999, 2000 Ingo Molnar
  4. completely rewritten, based on the MD driver code from Marc Zyngier
  5. Changes:
  6. - RAID-1/RAID-5 extensions by Miguel de Icaza, Gadi Oxman, Ingo Molnar
  7. - RAID-6 extensions by H. Peter Anvin <hpa@zytor.com>
  8. - boot support for linear and striped mode by Harald Hoyer <HarryH@Royal.Net>
  9. - kerneld support by Boris Tobotras <boris@xtalk.msk.su>
  10. - kmod support by: Cyrus Durgin
  11. - RAID0 bugfixes: Mark Anthony Lisher <markal@iname.com>
  12. - Devfs support by Richard Gooch <rgooch@atnf.csiro.au>
  13. - lots of fixes and improvements to the RAID1/RAID5 and generic
  14. RAID code (such as request based resynchronization):
  15. Neil Brown <neilb@cse.unsw.edu.au>.
  16. - persistent bitmap code
  17. Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.
  18. This program is free software; you can redistribute it and/or modify
  19. it under the terms of the GNU General Public License as published by
  20. the Free Software Foundation; either version 2, or (at your option)
  21. any later version.
  22. You should have received a copy of the GNU General Public License
  23. (for example /usr/src/linux/COPYING); if not, write to the Free
  24. Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25. */
  26. #include <linux/kthread.h>
  27. #include <linux/blkdev.h>
  28. #include <linux/sysctl.h>
  29. #include <linux/seq_file.h>
  30. #include <linux/smp_lock.h>
  31. #include <linux/buffer_head.h> /* for invalidate_bdev */
  32. #include <linux/poll.h>
  33. #include <linux/ctype.h>
  34. #include <linux/string.h>
  35. #include <linux/hdreg.h>
  36. #include <linux/proc_fs.h>
  37. #include <linux/random.h>
  38. #include <linux/reboot.h>
  39. #include <linux/file.h>
  40. #include <linux/compat.h>
  41. #include <linux/delay.h>
  42. #include <linux/raid/md_p.h>
  43. #include <linux/raid/md_u.h>
  44. #include <linux/slab.h>
  45. #include "md.h"
  46. #include "bitmap.h"
  47. #define DEBUG 0
  48. #define dprintk(x...) ((void)(DEBUG && printk(x)))
  49. #ifndef MODULE
  50. static void autostart_arrays(int part);
  51. #endif
  52. static LIST_HEAD(pers_list);
  53. static DEFINE_SPINLOCK(pers_lock);
  54. static void md_print_devices(void);
  55. static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
  56. #define MD_BUG(x...) { printk("md: bug in file %s, line %d\n", __FILE__, __LINE__); md_print_devices(); }
  57. /*
  58. * Default number of read corrections we'll attempt on an rdev
  59. * before ejecting it from the array. We divide the read error
  60. * count by 2 for every hour elapsed between read errors.
  61. */
  62. #define MD_DEFAULT_MAX_CORRECTED_READ_ERRORS 20
  63. /*
  64. * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
  65. * is 1000 KB/sec, so the extra system load does not show up that much.
  66. * Increase it if you want to have more _guaranteed_ speed. Note that
  67. * the RAID driver will use the maximum available bandwidth if the IO
  68. * subsystem is idle. There is also an 'absolute maximum' reconstruction
  69. * speed limit - in case reconstruction slows down your system despite
  70. * idle IO detection.
  71. *
  72. * you can change it via /proc/sys/dev/raid/speed_limit_min and _max.
  73. * or /sys/block/mdX/md/sync_speed_{min,max}
  74. */
  75. static int sysctl_speed_limit_min = 1000;
  76. static int sysctl_speed_limit_max = 200000;
  77. static inline int speed_min(mddev_t *mddev)
  78. {
  79. return mddev->sync_speed_min ?
  80. mddev->sync_speed_min : sysctl_speed_limit_min;
  81. }
  82. static inline int speed_max(mddev_t *mddev)
  83. {
  84. return mddev->sync_speed_max ?
  85. mddev->sync_speed_max : sysctl_speed_limit_max;
  86. }
  87. static struct ctl_table_header *raid_table_header;
  88. static ctl_table raid_table[] = {
  89. {
  90. .procname = "speed_limit_min",
  91. .data = &sysctl_speed_limit_min,
  92. .maxlen = sizeof(int),
  93. .mode = S_IRUGO|S_IWUSR,
  94. .proc_handler = proc_dointvec,
  95. },
  96. {
  97. .procname = "speed_limit_max",
  98. .data = &sysctl_speed_limit_max,
  99. .maxlen = sizeof(int),
  100. .mode = S_IRUGO|S_IWUSR,
  101. .proc_handler = proc_dointvec,
  102. },
  103. { }
  104. };
  105. static ctl_table raid_dir_table[] = {
  106. {
  107. .procname = "raid",
  108. .maxlen = 0,
  109. .mode = S_IRUGO|S_IXUGO,
  110. .child = raid_table,
  111. },
  112. { }
  113. };
  114. static ctl_table raid_root_table[] = {
  115. {
  116. .procname = "dev",
  117. .maxlen = 0,
  118. .mode = 0555,
  119. .child = raid_dir_table,
  120. },
  121. { }
  122. };
  123. static const struct block_device_operations md_fops;
  124. static int start_readonly;
  125. /*
  126. * We have a system wide 'event count' that is incremented
  127. * on any 'interesting' event, and readers of /proc/mdstat
  128. * can use 'poll' or 'select' to find out when the event
  129. * count increases.
  130. *
  131. * Events are:
  132. * start array, stop array, error, add device, remove device,
  133. * start build, activate spare
  134. */
  135. static DECLARE_WAIT_QUEUE_HEAD(md_event_waiters);
  136. static atomic_t md_event_count;
  137. void md_new_event(mddev_t *mddev)
  138. {
  139. atomic_inc(&md_event_count);
  140. wake_up(&md_event_waiters);
  141. }
  142. EXPORT_SYMBOL_GPL(md_new_event);
  143. /* Alternate version that can be called from interrupts
  144. * when calling sysfs_notify isn't needed.
  145. */
  146. static void md_new_event_inintr(mddev_t *mddev)
  147. {
  148. atomic_inc(&md_event_count);
  149. wake_up(&md_event_waiters);
  150. }
  151. /*
  152. * Enables to iterate over all existing md arrays
  153. * all_mddevs_lock protects this list.
  154. */
  155. static LIST_HEAD(all_mddevs);
  156. static DEFINE_SPINLOCK(all_mddevs_lock);
  157. /*
  158. * iterates through all used mddevs in the system.
  159. * We take care to grab the all_mddevs_lock whenever navigating
  160. * the list, and to always hold a refcount when unlocked.
  161. * Any code which breaks out of this loop while own
  162. * a reference to the current mddev and must mddev_put it.
  163. */
  164. #define for_each_mddev(mddev,tmp) \
  165. \
  166. for (({ spin_lock(&all_mddevs_lock); \
  167. tmp = all_mddevs.next; \
  168. mddev = NULL;}); \
  169. ({ if (tmp != &all_mddevs) \
  170. mddev_get(list_entry(tmp, mddev_t, all_mddevs));\
  171. spin_unlock(&all_mddevs_lock); \
  172. if (mddev) mddev_put(mddev); \
  173. mddev = list_entry(tmp, mddev_t, all_mddevs); \
  174. tmp != &all_mddevs;}); \
  175. ({ spin_lock(&all_mddevs_lock); \
  176. tmp = tmp->next;}) \
  177. )
  178. /* Rather than calling directly into the personality make_request function,
  179. * IO requests come here first so that we can check if the device is
  180. * being suspended pending a reconfiguration.
  181. * We hold a refcount over the call to ->make_request. By the time that
  182. * call has finished, the bio has been linked into some internal structure
  183. * and so is visible to ->quiesce(), so we don't need the refcount any more.
  184. */
  185. static int md_make_request(struct request_queue *q, struct bio *bio)
  186. {
  187. const int rw = bio_data_dir(bio);
  188. mddev_t *mddev = q->queuedata;
  189. int rv;
  190. int cpu;
  191. if (mddev == NULL || mddev->pers == NULL) {
  192. bio_io_error(bio);
  193. return 0;
  194. }
  195. rcu_read_lock();
  196. if (mddev->suspended || mddev->barrier) {
  197. DEFINE_WAIT(__wait);
  198. for (;;) {
  199. prepare_to_wait(&mddev->sb_wait, &__wait,
  200. TASK_UNINTERRUPTIBLE);
  201. if (!mddev->suspended && !mddev->barrier)
  202. break;
  203. rcu_read_unlock();
  204. schedule();
  205. rcu_read_lock();
  206. }
  207. finish_wait(&mddev->sb_wait, &__wait);
  208. }
  209. atomic_inc(&mddev->active_io);
  210. rcu_read_unlock();
  211. rv = mddev->pers->make_request(mddev, bio);
  212. cpu = part_stat_lock();
  213. part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]);
  214. part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw],
  215. bio_sectors(bio));
  216. part_stat_unlock();
  217. if (atomic_dec_and_test(&mddev->active_io) && mddev->suspended)
  218. wake_up(&mddev->sb_wait);
  219. return rv;
  220. }
  221. /* mddev_suspend makes sure no new requests are submitted
  222. * to the device, and that any requests that have been submitted
  223. * are completely handled.
  224. * Once ->stop is called and completes, the module will be completely
  225. * unused.
  226. */
  227. void mddev_suspend(mddev_t *mddev)
  228. {
  229. BUG_ON(mddev->suspended);
  230. mddev->suspended = 1;
  231. synchronize_rcu();
  232. wait_event(mddev->sb_wait, atomic_read(&mddev->active_io) == 0);
  233. mddev->pers->quiesce(mddev, 1);
  234. }
  235. EXPORT_SYMBOL_GPL(mddev_suspend);
  236. void mddev_resume(mddev_t *mddev)
  237. {
  238. mddev->suspended = 0;
  239. wake_up(&mddev->sb_wait);
  240. mddev->pers->quiesce(mddev, 0);
  241. }
  242. EXPORT_SYMBOL_GPL(mddev_resume);
  243. int mddev_congested(mddev_t *mddev, int bits)
  244. {
  245. if (mddev->barrier)
  246. return 1;
  247. return mddev->suspended;
  248. }
  249. EXPORT_SYMBOL(mddev_congested);
  250. /*
  251. * Generic barrier handling for md
  252. */
  253. #define POST_REQUEST_BARRIER ((void*)1)
  254. static void md_end_barrier(struct bio *bio, int err)
  255. {
  256. mdk_rdev_t *rdev = bio->bi_private;
  257. mddev_t *mddev = rdev->mddev;
  258. if (err == -EOPNOTSUPP && mddev->barrier != POST_REQUEST_BARRIER)
  259. set_bit(BIO_EOPNOTSUPP, &mddev->barrier->bi_flags);
  260. rdev_dec_pending(rdev, mddev);
  261. if (atomic_dec_and_test(&mddev->flush_pending)) {
  262. if (mddev->barrier == POST_REQUEST_BARRIER) {
  263. /* This was a post-request barrier */
  264. mddev->barrier = NULL;
  265. wake_up(&mddev->sb_wait);
  266. } else
  267. /* The pre-request barrier has finished */
  268. schedule_work(&mddev->barrier_work);
  269. }
  270. bio_put(bio);
  271. }
  272. static void submit_barriers(mddev_t *mddev)
  273. {
  274. mdk_rdev_t *rdev;
  275. rcu_read_lock();
  276. list_for_each_entry_rcu(rdev, &mddev->disks, same_set)
  277. if (rdev->raid_disk >= 0 &&
  278. !test_bit(Faulty, &rdev->flags)) {
  279. /* Take two references, one is dropped
  280. * when request finishes, one after
  281. * we reclaim rcu_read_lock
  282. */
  283. struct bio *bi;
  284. atomic_inc(&rdev->nr_pending);
  285. atomic_inc(&rdev->nr_pending);
  286. rcu_read_unlock();
  287. bi = bio_alloc(GFP_KERNEL, 0);
  288. bi->bi_end_io = md_end_barrier;
  289. bi->bi_private = rdev;
  290. bi->bi_bdev = rdev->bdev;
  291. atomic_inc(&mddev->flush_pending);
  292. submit_bio(WRITE_BARRIER, bi);
  293. rcu_read_lock();
  294. rdev_dec_pending(rdev, mddev);
  295. }
  296. rcu_read_unlock();
  297. }
  298. static void md_submit_barrier(struct work_struct *ws)
  299. {
  300. mddev_t *mddev = container_of(ws, mddev_t, barrier_work);
  301. struct bio *bio = mddev->barrier;
  302. atomic_set(&mddev->flush_pending, 1);
  303. if (test_bit(BIO_EOPNOTSUPP, &bio->bi_flags))
  304. bio_endio(bio, -EOPNOTSUPP);
  305. else if (bio->bi_size == 0)
  306. /* an empty barrier - all done */
  307. bio_endio(bio, 0);
  308. else {
  309. bio->bi_rw &= ~REQ_HARDBARRIER;
  310. if (mddev->pers->make_request(mddev, bio))
  311. generic_make_request(bio);
  312. mddev->barrier = POST_REQUEST_BARRIER;
  313. submit_barriers(mddev);
  314. }
  315. if (atomic_dec_and_test(&mddev->flush_pending)) {
  316. mddev->barrier = NULL;
  317. wake_up(&mddev->sb_wait);
  318. }
  319. }
  320. void md_barrier_request(mddev_t *mddev, struct bio *bio)
  321. {
  322. spin_lock_irq(&mddev->write_lock);
  323. wait_event_lock_irq(mddev->sb_wait,
  324. !mddev->barrier,
  325. mddev->write_lock, /*nothing*/);
  326. mddev->barrier = bio;
  327. spin_unlock_irq(&mddev->write_lock);
  328. atomic_set(&mddev->flush_pending, 1);
  329. INIT_WORK(&mddev->barrier_work, md_submit_barrier);
  330. submit_barriers(mddev);
  331. if (atomic_dec_and_test(&mddev->flush_pending))
  332. schedule_work(&mddev->barrier_work);
  333. }
  334. EXPORT_SYMBOL(md_barrier_request);
  335. /* Support for plugging.
  336. * This mirrors the plugging support in request_queue, but does not
  337. * require having a whole queue
  338. */
  339. static void plugger_work(struct work_struct *work)
  340. {
  341. struct plug_handle *plug =
  342. container_of(work, struct plug_handle, unplug_work);
  343. plug->unplug_fn(plug);
  344. }
  345. static void plugger_timeout(unsigned long data)
  346. {
  347. struct plug_handle *plug = (void *)data;
  348. kblockd_schedule_work(NULL, &plug->unplug_work);
  349. }
  350. void plugger_init(struct plug_handle *plug,
  351. void (*unplug_fn)(struct plug_handle *))
  352. {
  353. plug->unplug_flag = 0;
  354. plug->unplug_fn = unplug_fn;
  355. init_timer(&plug->unplug_timer);
  356. plug->unplug_timer.function = plugger_timeout;
  357. plug->unplug_timer.data = (unsigned long)plug;
  358. INIT_WORK(&plug->unplug_work, plugger_work);
  359. }
  360. EXPORT_SYMBOL_GPL(plugger_init);
  361. void plugger_set_plug(struct plug_handle *plug)
  362. {
  363. if (!test_and_set_bit(PLUGGED_FLAG, &plug->unplug_flag))
  364. mod_timer(&plug->unplug_timer, jiffies + msecs_to_jiffies(3)+1);
  365. }
  366. EXPORT_SYMBOL_GPL(plugger_set_plug);
  367. int plugger_remove_plug(struct plug_handle *plug)
  368. {
  369. if (test_and_clear_bit(PLUGGED_FLAG, &plug->unplug_flag)) {
  370. del_timer(&plug->unplug_timer);
  371. return 1;
  372. } else
  373. return 0;
  374. }
  375. EXPORT_SYMBOL_GPL(plugger_remove_plug);
  376. static inline mddev_t *mddev_get(mddev_t *mddev)
  377. {
  378. atomic_inc(&mddev->active);
  379. return mddev;
  380. }
  381. static void mddev_delayed_delete(struct work_struct *ws);
  382. static void mddev_put(mddev_t *mddev)
  383. {
  384. if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
  385. return;
  386. if (!mddev->raid_disks && list_empty(&mddev->disks) &&
  387. mddev->ctime == 0 && !mddev->hold_active) {
  388. /* Array is not configured at all, and not held active,
  389. * so destroy it */
  390. list_del(&mddev->all_mddevs);
  391. if (mddev->gendisk) {
  392. /* we did a probe so need to clean up.
  393. * Call schedule_work inside the spinlock
  394. * so that flush_scheduled_work() after
  395. * mddev_find will succeed in waiting for the
  396. * work to be done.
  397. */
  398. INIT_WORK(&mddev->del_work, mddev_delayed_delete);
  399. schedule_work(&mddev->del_work);
  400. } else
  401. kfree(mddev);
  402. }
  403. spin_unlock(&all_mddevs_lock);
  404. }
  405. void mddev_init(mddev_t *mddev)
  406. {
  407. mutex_init(&mddev->open_mutex);
  408. mutex_init(&mddev->reconfig_mutex);
  409. mutex_init(&mddev->bitmap_info.mutex);
  410. INIT_LIST_HEAD(&mddev->disks);
  411. INIT_LIST_HEAD(&mddev->all_mddevs);
  412. init_timer(&mddev->safemode_timer);
  413. atomic_set(&mddev->active, 1);
  414. atomic_set(&mddev->openers, 0);
  415. atomic_set(&mddev->active_io, 0);
  416. spin_lock_init(&mddev->write_lock);
  417. atomic_set(&mddev->flush_pending, 0);
  418. init_waitqueue_head(&mddev->sb_wait);
  419. init_waitqueue_head(&mddev->recovery_wait);
  420. mddev->reshape_position = MaxSector;
  421. mddev->resync_min = 0;
  422. mddev->resync_max = MaxSector;
  423. mddev->level = LEVEL_NONE;
  424. }
  425. EXPORT_SYMBOL_GPL(mddev_init);
  426. static mddev_t * mddev_find(dev_t unit)
  427. {
  428. mddev_t *mddev, *new = NULL;
  429. retry:
  430. spin_lock(&all_mddevs_lock);
  431. if (unit) {
  432. list_for_each_entry(mddev, &all_mddevs, all_mddevs)
  433. if (mddev->unit == unit) {
  434. mddev_get(mddev);
  435. spin_unlock(&all_mddevs_lock);
  436. kfree(new);
  437. return mddev;
  438. }
  439. if (new) {
  440. list_add(&new->all_mddevs, &all_mddevs);
  441. spin_unlock(&all_mddevs_lock);
  442. new->hold_active = UNTIL_IOCTL;
  443. return new;
  444. }
  445. } else if (new) {
  446. /* find an unused unit number */
  447. static int next_minor = 512;
  448. int start = next_minor;
  449. int is_free = 0;
  450. int dev = 0;
  451. while (!is_free) {
  452. dev = MKDEV(MD_MAJOR, next_minor);
  453. next_minor++;
  454. if (next_minor > MINORMASK)
  455. next_minor = 0;
  456. if (next_minor == start) {
  457. /* Oh dear, all in use. */
  458. spin_unlock(&all_mddevs_lock);
  459. kfree(new);
  460. return NULL;
  461. }
  462. is_free = 1;
  463. list_for_each_entry(mddev, &all_mddevs, all_mddevs)
  464. if (mddev->unit == dev) {
  465. is_free = 0;
  466. break;
  467. }
  468. }
  469. new->unit = dev;
  470. new->md_minor = MINOR(dev);
  471. new->hold_active = UNTIL_STOP;
  472. list_add(&new->all_mddevs, &all_mddevs);
  473. spin_unlock(&all_mddevs_lock);
  474. return new;
  475. }
  476. spin_unlock(&all_mddevs_lock);
  477. new = kzalloc(sizeof(*new), GFP_KERNEL);
  478. if (!new)
  479. return NULL;
  480. new->unit = unit;
  481. if (MAJOR(unit) == MD_MAJOR)
  482. new->md_minor = MINOR(unit);
  483. else
  484. new->md_minor = MINOR(unit) >> MdpMinorShift;
  485. mddev_init(new);
  486. goto retry;
  487. }
  488. static inline int mddev_lock(mddev_t * mddev)
  489. {
  490. return mutex_lock_interruptible(&mddev->reconfig_mutex);
  491. }
  492. static inline int mddev_is_locked(mddev_t *mddev)
  493. {
  494. return mutex_is_locked(&mddev->reconfig_mutex);
  495. }
  496. static inline int mddev_trylock(mddev_t * mddev)
  497. {
  498. return mutex_trylock(&mddev->reconfig_mutex);
  499. }
  500. static struct attribute_group md_redundancy_group;
  501. static void mddev_unlock(mddev_t * mddev)
  502. {
  503. if (mddev->to_remove) {
  504. /* These cannot be removed under reconfig_mutex as
  505. * an access to the files will try to take reconfig_mutex
  506. * while holding the file unremovable, which leads to
  507. * a deadlock.
  508. * So hold set sysfs_active while the remove in happeing,
  509. * and anything else which might set ->to_remove or my
  510. * otherwise change the sysfs namespace will fail with
  511. * -EBUSY if sysfs_active is still set.
  512. * We set sysfs_active under reconfig_mutex and elsewhere
  513. * test it under the same mutex to ensure its correct value
  514. * is seen.
  515. */
  516. struct attribute_group *to_remove = mddev->to_remove;
  517. mddev->to_remove = NULL;
  518. mddev->sysfs_active = 1;
  519. mutex_unlock(&mddev->reconfig_mutex);
  520. if (mddev->kobj.sd) {
  521. if (to_remove != &md_redundancy_group)
  522. sysfs_remove_group(&mddev->kobj, to_remove);
  523. if (mddev->pers == NULL ||
  524. mddev->pers->sync_request == NULL) {
  525. sysfs_remove_group(&mddev->kobj, &md_redundancy_group);
  526. if (mddev->sysfs_action)
  527. sysfs_put(mddev->sysfs_action);
  528. mddev->sysfs_action = NULL;
  529. }
  530. }
  531. mddev->sysfs_active = 0;
  532. } else
  533. mutex_unlock(&mddev->reconfig_mutex);
  534. md_wakeup_thread(mddev->thread);
  535. }
  536. static mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr)
  537. {
  538. mdk_rdev_t *rdev;
  539. list_for_each_entry(rdev, &mddev->disks, same_set)
  540. if (rdev->desc_nr == nr)
  541. return rdev;
  542. return NULL;
  543. }
  544. static mdk_rdev_t * find_rdev(mddev_t * mddev, dev_t dev)
  545. {
  546. mdk_rdev_t *rdev;
  547. list_for_each_entry(rdev, &mddev->disks, same_set)
  548. if (rdev->bdev->bd_dev == dev)
  549. return rdev;
  550. return NULL;
  551. }
  552. static struct mdk_personality *find_pers(int level, char *clevel)
  553. {
  554. struct mdk_personality *pers;
  555. list_for_each_entry(pers, &pers_list, list) {
  556. if (level != LEVEL_NONE && pers->level == level)
  557. return pers;
  558. if (strcmp(pers->name, clevel)==0)
  559. return pers;
  560. }
  561. return NULL;
  562. }
  563. /* return the offset of the super block in 512byte sectors */
  564. static inline sector_t calc_dev_sboffset(struct block_device *bdev)
  565. {
  566. sector_t num_sectors = bdev->bd_inode->i_size / 512;
  567. return MD_NEW_SIZE_SECTORS(num_sectors);
  568. }
  569. static int alloc_disk_sb(mdk_rdev_t * rdev)
  570. {
  571. if (rdev->sb_page)
  572. MD_BUG();
  573. rdev->sb_page = alloc_page(GFP_KERNEL);
  574. if (!rdev->sb_page) {
  575. printk(KERN_ALERT "md: out of memory.\n");
  576. return -ENOMEM;
  577. }
  578. return 0;
  579. }
  580. static void free_disk_sb(mdk_rdev_t * rdev)
  581. {
  582. if (rdev->sb_page) {
  583. put_page(rdev->sb_page);
  584. rdev->sb_loaded = 0;
  585. rdev->sb_page = NULL;
  586. rdev->sb_start = 0;
  587. rdev->sectors = 0;
  588. }
  589. }
  590. static void super_written(struct bio *bio, int error)
  591. {
  592. mdk_rdev_t *rdev = bio->bi_private;
  593. mddev_t *mddev = rdev->mddev;
  594. if (error || !test_bit(BIO_UPTODATE, &bio->bi_flags)) {
  595. printk("md: super_written gets error=%d, uptodate=%d\n",
  596. error, test_bit(BIO_UPTODATE, &bio->bi_flags));
  597. WARN_ON(test_bit(BIO_UPTODATE, &bio->bi_flags));
  598. md_error(mddev, rdev);
  599. }
  600. if (atomic_dec_and_test(&mddev->pending_writes))
  601. wake_up(&mddev->sb_wait);
  602. bio_put(bio);
  603. }
  604. static void super_written_barrier(struct bio *bio, int error)
  605. {
  606. struct bio *bio2 = bio->bi_private;
  607. mdk_rdev_t *rdev = bio2->bi_private;
  608. mddev_t *mddev = rdev->mddev;
  609. if (!test_bit(BIO_UPTODATE, &bio->bi_flags) &&
  610. error == -EOPNOTSUPP) {
  611. unsigned long flags;
  612. /* barriers don't appear to be supported :-( */
  613. set_bit(BarriersNotsupp, &rdev->flags);
  614. mddev->barriers_work = 0;
  615. spin_lock_irqsave(&mddev->write_lock, flags);
  616. bio2->bi_next = mddev->biolist;
  617. mddev->biolist = bio2;
  618. spin_unlock_irqrestore(&mddev->write_lock, flags);
  619. wake_up(&mddev->sb_wait);
  620. bio_put(bio);
  621. } else {
  622. bio_put(bio2);
  623. bio->bi_private = rdev;
  624. super_written(bio, error);
  625. }
  626. }
  627. void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
  628. sector_t sector, int size, struct page *page)
  629. {
  630. /* write first size bytes of page to sector of rdev
  631. * Increment mddev->pending_writes before returning
  632. * and decrement it on completion, waking up sb_wait
  633. * if zero is reached.
  634. * If an error occurred, call md_error
  635. *
  636. * As we might need to resubmit the request if REQ_HARDBARRIER
  637. * causes ENOTSUPP, we allocate a spare bio...
  638. */
  639. struct bio *bio = bio_alloc(GFP_NOIO, 1);
  640. int rw = REQ_WRITE | REQ_SYNC | REQ_UNPLUG;
  641. bio->bi_bdev = rdev->bdev;
  642. bio->bi_sector = sector;
  643. bio_add_page(bio, page, size, 0);
  644. bio->bi_private = rdev;
  645. bio->bi_end_io = super_written;
  646. bio->bi_rw = rw;
  647. atomic_inc(&mddev->pending_writes);
  648. if (!test_bit(BarriersNotsupp, &rdev->flags)) {
  649. struct bio *rbio;
  650. rw |= REQ_HARDBARRIER;
  651. rbio = bio_clone(bio, GFP_NOIO);
  652. rbio->bi_private = bio;
  653. rbio->bi_end_io = super_written_barrier;
  654. submit_bio(rw, rbio);
  655. } else
  656. submit_bio(rw, bio);
  657. }
  658. void md_super_wait(mddev_t *mddev)
  659. {
  660. /* wait for all superblock writes that were scheduled to complete.
  661. * if any had to be retried (due to BARRIER problems), retry them
  662. */
  663. DEFINE_WAIT(wq);
  664. for(;;) {
  665. prepare_to_wait(&mddev->sb_wait, &wq, TASK_UNINTERRUPTIBLE);
  666. if (atomic_read(&mddev->pending_writes)==0)
  667. break;
  668. while (mddev->biolist) {
  669. struct bio *bio;
  670. spin_lock_irq(&mddev->write_lock);
  671. bio = mddev->biolist;
  672. mddev->biolist = bio->bi_next ;
  673. bio->bi_next = NULL;
  674. spin_unlock_irq(&mddev->write_lock);
  675. submit_bio(bio->bi_rw, bio);
  676. }
  677. schedule();
  678. }
  679. finish_wait(&mddev->sb_wait, &wq);
  680. }
  681. static void bi_complete(struct bio *bio, int error)
  682. {
  683. complete((struct completion*)bio->bi_private);
  684. }
  685. int sync_page_io(struct block_device *bdev, sector_t sector, int size,
  686. struct page *page, int rw)
  687. {
  688. struct bio *bio = bio_alloc(GFP_NOIO, 1);
  689. struct completion event;
  690. int ret;
  691. rw |= REQ_SYNC | REQ_UNPLUG;
  692. bio->bi_bdev = bdev;
  693. bio->bi_sector = sector;
  694. bio_add_page(bio, page, size, 0);
  695. init_completion(&event);
  696. bio->bi_private = &event;
  697. bio->bi_end_io = bi_complete;
  698. submit_bio(rw, bio);
  699. wait_for_completion(&event);
  700. ret = test_bit(BIO_UPTODATE, &bio->bi_flags);
  701. bio_put(bio);
  702. return ret;
  703. }
  704. EXPORT_SYMBOL_GPL(sync_page_io);
  705. static int read_disk_sb(mdk_rdev_t * rdev, int size)
  706. {
  707. char b[BDEVNAME_SIZE];
  708. if (!rdev->sb_page) {
  709. MD_BUG();
  710. return -EINVAL;
  711. }
  712. if (rdev->sb_loaded)
  713. return 0;
  714. if (!sync_page_io(rdev->bdev, rdev->sb_start, size, rdev->sb_page, READ))
  715. goto fail;
  716. rdev->sb_loaded = 1;
  717. return 0;
  718. fail:
  719. printk(KERN_WARNING "md: disabled device %s, could not read superblock.\n",
  720. bdevname(rdev->bdev,b));
  721. return -EINVAL;
  722. }
  723. static int uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
  724. {
  725. return sb1->set_uuid0 == sb2->set_uuid0 &&
  726. sb1->set_uuid1 == sb2->set_uuid1 &&
  727. sb1->set_uuid2 == sb2->set_uuid2 &&
  728. sb1->set_uuid3 == sb2->set_uuid3;
  729. }
  730. static int sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
  731. {
  732. int ret;
  733. mdp_super_t *tmp1, *tmp2;
  734. tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
  735. tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
  736. if (!tmp1 || !tmp2) {
  737. ret = 0;
  738. printk(KERN_INFO "md.c sb_equal(): failed to allocate memory!\n");
  739. goto abort;
  740. }
  741. *tmp1 = *sb1;
  742. *tmp2 = *sb2;
  743. /*
  744. * nr_disks is not constant
  745. */
  746. tmp1->nr_disks = 0;
  747. tmp2->nr_disks = 0;
  748. ret = (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4) == 0);
  749. abort:
  750. kfree(tmp1);
  751. kfree(tmp2);
  752. return ret;
  753. }
  754. static u32 md_csum_fold(u32 csum)
  755. {
  756. csum = (csum & 0xffff) + (csum >> 16);
  757. return (csum & 0xffff) + (csum >> 16);
  758. }
  759. static unsigned int calc_sb_csum(mdp_super_t * sb)
  760. {
  761. u64 newcsum = 0;
  762. u32 *sb32 = (u32*)sb;
  763. int i;
  764. unsigned int disk_csum, csum;
  765. disk_csum = sb->sb_csum;
  766. sb->sb_csum = 0;
  767. for (i = 0; i < MD_SB_BYTES/4 ; i++)
  768. newcsum += sb32[i];
  769. csum = (newcsum & 0xffffffff) + (newcsum>>32);
  770. #ifdef CONFIG_ALPHA
  771. /* This used to use csum_partial, which was wrong for several
  772. * reasons including that different results are returned on
  773. * different architectures. It isn't critical that we get exactly
  774. * the same return value as before (we always csum_fold before
  775. * testing, and that removes any differences). However as we
  776. * know that csum_partial always returned a 16bit value on
  777. * alphas, do a fold to maximise conformity to previous behaviour.
  778. */
  779. sb->sb_csum = md_csum_fold(disk_csum);
  780. #else
  781. sb->sb_csum = disk_csum;
  782. #endif
  783. return csum;
  784. }
  785. /*
  786. * Handle superblock details.
  787. * We want to be able to handle multiple superblock formats
  788. * so we have a common interface to them all, and an array of
  789. * different handlers.
  790. * We rely on user-space to write the initial superblock, and support
  791. * reading and updating of superblocks.
  792. * Interface methods are:
  793. * int load_super(mdk_rdev_t *dev, mdk_rdev_t *refdev, int minor_version)
  794. * loads and validates a superblock on dev.
  795. * if refdev != NULL, compare superblocks on both devices
  796. * Return:
  797. * 0 - dev has a superblock that is compatible with refdev
  798. * 1 - dev has a superblock that is compatible and newer than refdev
  799. * so dev should be used as the refdev in future
  800. * -EINVAL superblock incompatible or invalid
  801. * -othererror e.g. -EIO
  802. *
  803. * int validate_super(mddev_t *mddev, mdk_rdev_t *dev)
  804. * Verify that dev is acceptable into mddev.
  805. * The first time, mddev->raid_disks will be 0, and data from
  806. * dev should be merged in. Subsequent calls check that dev
  807. * is new enough. Return 0 or -EINVAL
  808. *
  809. * void sync_super(mddev_t *mddev, mdk_rdev_t *dev)
  810. * Update the superblock for rdev with data in mddev
  811. * This does not write to disc.
  812. *
  813. */
  814. struct super_type {
  815. char *name;
  816. struct module *owner;
  817. int (*load_super)(mdk_rdev_t *rdev, mdk_rdev_t *refdev,
  818. int minor_version);
  819. int (*validate_super)(mddev_t *mddev, mdk_rdev_t *rdev);
  820. void (*sync_super)(mddev_t *mddev, mdk_rdev_t *rdev);
  821. unsigned long long (*rdev_size_change)(mdk_rdev_t *rdev,
  822. sector_t num_sectors);
  823. };
  824. /*
  825. * Check that the given mddev has no bitmap.
  826. *
  827. * This function is called from the run method of all personalities that do not
  828. * support bitmaps. It prints an error message and returns non-zero if mddev
  829. * has a bitmap. Otherwise, it returns 0.
  830. *
  831. */
  832. int md_check_no_bitmap(mddev_t *mddev)
  833. {
  834. if (!mddev->bitmap_info.file && !mddev->bitmap_info.offset)
  835. return 0;
  836. printk(KERN_ERR "%s: bitmaps are not supported for %s\n",
  837. mdname(mddev), mddev->pers->name);
  838. return 1;
  839. }
  840. EXPORT_SYMBOL(md_check_no_bitmap);
  841. /*
  842. * load_super for 0.90.0
  843. */
  844. static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
  845. {
  846. char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
  847. mdp_super_t *sb;
  848. int ret;
  849. /*
  850. * Calculate the position of the superblock (512byte sectors),
  851. * it's at the end of the disk.
  852. *
  853. * It also happens to be a multiple of 4Kb.
  854. */
  855. rdev->sb_start = calc_dev_sboffset(rdev->bdev);
  856. ret = read_disk_sb(rdev, MD_SB_BYTES);
  857. if (ret) return ret;
  858. ret = -EINVAL;
  859. bdevname(rdev->bdev, b);
  860. sb = (mdp_super_t*)page_address(rdev->sb_page);
  861. if (sb->md_magic != MD_SB_MAGIC) {
  862. printk(KERN_ERR "md: invalid raid superblock magic on %s\n",
  863. b);
  864. goto abort;
  865. }
  866. if (sb->major_version != 0 ||
  867. sb->minor_version < 90 ||
  868. sb->minor_version > 91) {
  869. printk(KERN_WARNING "Bad version number %d.%d on %s\n",
  870. sb->major_version, sb->minor_version,
  871. b);
  872. goto abort;
  873. }
  874. if (sb->raid_disks <= 0)
  875. goto abort;
  876. if (md_csum_fold(calc_sb_csum(sb)) != md_csum_fold(sb->sb_csum)) {
  877. printk(KERN_WARNING "md: invalid superblock checksum on %s\n",
  878. b);
  879. goto abort;
  880. }
  881. rdev->preferred_minor = sb->md_minor;
  882. rdev->data_offset = 0;
  883. rdev->sb_size = MD_SB_BYTES;
  884. if (sb->level == LEVEL_MULTIPATH)
  885. rdev->desc_nr = -1;
  886. else
  887. rdev->desc_nr = sb->this_disk.number;
  888. if (!refdev) {
  889. ret = 1;
  890. } else {
  891. __u64 ev1, ev2;
  892. mdp_super_t *refsb = (mdp_super_t*)page_address(refdev->sb_page);
  893. if (!uuid_equal(refsb, sb)) {
  894. printk(KERN_WARNING "md: %s has different UUID to %s\n",
  895. b, bdevname(refdev->bdev,b2));
  896. goto abort;
  897. }
  898. if (!sb_equal(refsb, sb)) {
  899. printk(KERN_WARNING "md: %s has same UUID"
  900. " but different superblock to %s\n",
  901. b, bdevname(refdev->bdev, b2));
  902. goto abort;
  903. }
  904. ev1 = md_event(sb);
  905. ev2 = md_event(refsb);
  906. if (ev1 > ev2)
  907. ret = 1;
  908. else
  909. ret = 0;
  910. }
  911. rdev->sectors = rdev->sb_start;
  912. if (rdev->sectors < sb->size * 2 && sb->level > 1)
  913. /* "this cannot possibly happen" ... */
  914. ret = -EINVAL;
  915. abort:
  916. return ret;
  917. }
  918. /*
  919. * validate_super for 0.90.0
  920. */
  921. static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
  922. {
  923. mdp_disk_t *desc;
  924. mdp_super_t *sb = (mdp_super_t *)page_address(rdev->sb_page);
  925. __u64 ev1 = md_event(sb);
  926. rdev->raid_disk = -1;
  927. clear_bit(Faulty, &rdev->flags);
  928. clear_bit(In_sync, &rdev->flags);
  929. clear_bit(WriteMostly, &rdev->flags);
  930. clear_bit(BarriersNotsupp, &rdev->flags);
  931. if (mddev->raid_disks == 0) {
  932. mddev->major_version = 0;
  933. mddev->minor_version = sb->minor_version;
  934. mddev->patch_version = sb->patch_version;
  935. mddev->external = 0;
  936. mddev->chunk_sectors = sb->chunk_size >> 9;
  937. mddev->ctime = sb->ctime;
  938. mddev->utime = sb->utime;
  939. mddev->level = sb->level;
  940. mddev->clevel[0] = 0;
  941. mddev->layout = sb->layout;
  942. mddev->raid_disks = sb->raid_disks;
  943. mddev->dev_sectors = sb->size * 2;
  944. mddev->events = ev1;
  945. mddev->bitmap_info.offset = 0;
  946. mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
  947. if (mddev->minor_version >= 91) {
  948. mddev->reshape_position = sb->reshape_position;
  949. mddev->delta_disks = sb->delta_disks;
  950. mddev->new_level = sb->new_level;
  951. mddev->new_layout = sb->new_layout;
  952. mddev->new_chunk_sectors = sb->new_chunk >> 9;
  953. } else {
  954. mddev->reshape_position = MaxSector;
  955. mddev->delta_disks = 0;
  956. mddev->new_level = mddev->level;
  957. mddev->new_layout = mddev->layout;
  958. mddev->new_chunk_sectors = mddev->chunk_sectors;
  959. }
  960. if (sb->state & (1<<MD_SB_CLEAN))
  961. mddev->recovery_cp = MaxSector;
  962. else {
  963. if (sb->events_hi == sb->cp_events_hi &&
  964. sb->events_lo == sb->cp_events_lo) {
  965. mddev->recovery_cp = sb->recovery_cp;
  966. } else
  967. mddev->recovery_cp = 0;
  968. }
  969. memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
  970. memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
  971. memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
  972. memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
  973. mddev->max_disks = MD_SB_DISKS;
  974. if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
  975. mddev->bitmap_info.file == NULL)
  976. mddev->bitmap_info.offset =
  977. mddev->bitmap_info.default_offset;
  978. } else if (mddev->pers == NULL) {
  979. /* Insist on good event counter while assembling, except
  980. * for spares (which don't need an event count) */
  981. ++ev1;
  982. if (sb->disks[rdev->desc_nr].state & (
  983. (1<<MD_DISK_SYNC) | (1 << MD_DISK_ACTIVE)))
  984. if (ev1 < mddev->events)
  985. return -EINVAL;
  986. } else if (mddev->bitmap) {
  987. /* if adding to array with a bitmap, then we can accept an
  988. * older device ... but not too old.
  989. */
  990. if (ev1 < mddev->bitmap->events_cleared)
  991. return 0;
  992. } else {
  993. if (ev1 < mddev->events)
  994. /* just a hot-add of a new device, leave raid_disk at -1 */
  995. return 0;
  996. }
  997. if (mddev->level != LEVEL_MULTIPATH) {
  998. desc = sb->disks + rdev->desc_nr;
  999. if (desc->state & (1<<MD_DISK_FAULTY))
  1000. set_bit(Faulty, &rdev->flags);
  1001. else if (desc->state & (1<<MD_DISK_SYNC) /* &&
  1002. desc->raid_disk < mddev->raid_disks */) {
  1003. set_bit(In_sync, &rdev->flags);
  1004. rdev->raid_disk = desc->raid_disk;
  1005. } else if (desc->state & (1<<MD_DISK_ACTIVE)) {
  1006. /* active but not in sync implies recovery up to
  1007. * reshape position. We don't know exactly where
  1008. * that is, so set to zero for now */
  1009. if (mddev->minor_version >= 91) {
  1010. rdev->recovery_offset = 0;
  1011. rdev->raid_disk = desc->raid_disk;
  1012. }
  1013. }
  1014. if (desc->state & (1<<MD_DISK_WRITEMOSTLY))
  1015. set_bit(WriteMostly, &rdev->flags);
  1016. } else /* MULTIPATH are always insync */
  1017. set_bit(In_sync, &rdev->flags);
  1018. return 0;
  1019. }
  1020. /*
  1021. * sync_super for 0.90.0
  1022. */
  1023. static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
  1024. {
  1025. mdp_super_t *sb;
  1026. mdk_rdev_t *rdev2;
  1027. int next_spare = mddev->raid_disks;
  1028. /* make rdev->sb match mddev data..
  1029. *
  1030. * 1/ zero out disks
  1031. * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare);
  1032. * 3/ any empty disks < next_spare become removed
  1033. *
  1034. * disks[0] gets initialised to REMOVED because
  1035. * we cannot be sure from other fields if it has
  1036. * been initialised or not.
  1037. */
  1038. int i;
  1039. int active=0, working=0,failed=0,spare=0,nr_disks=0;
  1040. rdev->sb_size = MD_SB_BYTES;
  1041. sb = (mdp_super_t*)page_address(rdev->sb_page);
  1042. memset(sb, 0, sizeof(*sb));
  1043. sb->md_magic = MD_SB_MAGIC;
  1044. sb->major_version = mddev->major_version;
  1045. sb->patch_version = mddev->patch_version;
  1046. sb->gvalid_words = 0; /* ignored */
  1047. memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
  1048. memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
  1049. memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
  1050. memcpy(&sb->set_uuid3, mddev->uuid+12,4);
  1051. sb->ctime = mddev->ctime;
  1052. sb->level = mddev->level;
  1053. sb->size = mddev->dev_sectors / 2;
  1054. sb->raid_disks = mddev->raid_disks;
  1055. sb->md_minor = mddev->md_minor;
  1056. sb->not_persistent = 0;
  1057. sb->utime = mddev->utime;
  1058. sb->state = 0;
  1059. sb->events_hi = (mddev->events>>32);
  1060. sb->events_lo = (u32)mddev->events;
  1061. if (mddev->reshape_position == MaxSector)
  1062. sb->minor_version = 90;
  1063. else {
  1064. sb->minor_version = 91;
  1065. sb->reshape_position = mddev->reshape_position;
  1066. sb->new_level = mddev->new_level;
  1067. sb->delta_disks = mddev->delta_disks;
  1068. sb->new_layout = mddev->new_layout;
  1069. sb->new_chunk = mddev->new_chunk_sectors << 9;
  1070. }
  1071. mddev->minor_version = sb->minor_version;
  1072. if (mddev->in_sync)
  1073. {
  1074. sb->recovery_cp = mddev->recovery_cp;
  1075. sb->cp_events_hi = (mddev->events>>32);
  1076. sb->cp_events_lo = (u32)mddev->events;
  1077. if (mddev->recovery_cp == MaxSector)
  1078. sb->state = (1<< MD_SB_CLEAN);
  1079. } else
  1080. sb->recovery_cp = 0;
  1081. sb->layout = mddev->layout;
  1082. sb->chunk_size = mddev->chunk_sectors << 9;
  1083. if (mddev->bitmap && mddev->bitmap_info.file == NULL)
  1084. sb->state |= (1<<MD_SB_BITMAP_PRESENT);
  1085. sb->disks[0].state = (1<<MD_DISK_REMOVED);
  1086. list_for_each_entry(rdev2, &mddev->disks, same_set) {
  1087. mdp_disk_t *d;
  1088. int desc_nr;
  1089. int is_active = test_bit(In_sync, &rdev2->flags);
  1090. if (rdev2->raid_disk >= 0 &&
  1091. sb->minor_version >= 91)
  1092. /* we have nowhere to store the recovery_offset,
  1093. * but if it is not below the reshape_position,
  1094. * we can piggy-back on that.
  1095. */
  1096. is_active = 1;
  1097. if (rdev2->raid_disk < 0 ||
  1098. test_bit(Faulty, &rdev2->flags))
  1099. is_active = 0;
  1100. if (is_active)
  1101. desc_nr = rdev2->raid_disk;
  1102. else
  1103. desc_nr = next_spare++;
  1104. rdev2->desc_nr = desc_nr;
  1105. d = &sb->disks[rdev2->desc_nr];
  1106. nr_disks++;
  1107. d->number = rdev2->desc_nr;
  1108. d->major = MAJOR(rdev2->bdev->bd_dev);
  1109. d->minor = MINOR(rdev2->bdev->bd_dev);
  1110. if (is_active)
  1111. d->raid_disk = rdev2->raid_disk;
  1112. else
  1113. d->raid_disk = rdev2->desc_nr; /* compatibility */
  1114. if (test_bit(Faulty, &rdev2->flags))
  1115. d->state = (1<<MD_DISK_FAULTY);
  1116. else if (is_active) {
  1117. d->state = (1<<MD_DISK_ACTIVE);
  1118. if (test_bit(In_sync, &rdev2->flags))
  1119. d->state |= (1<<MD_DISK_SYNC);
  1120. active++;
  1121. working++;
  1122. } else {
  1123. d->state = 0;
  1124. spare++;
  1125. working++;
  1126. }
  1127. if (test_bit(WriteMostly, &rdev2->flags))
  1128. d->state |= (1<<MD_DISK_WRITEMOSTLY);
  1129. }
  1130. /* now set the "removed" and "faulty" bits on any missing devices */
  1131. for (i=0 ; i < mddev->raid_disks ; i++) {
  1132. mdp_disk_t *d = &sb->disks[i];
  1133. if (d->state == 0 && d->number == 0) {
  1134. d->number = i;
  1135. d->raid_disk = i;
  1136. d->state = (1<<MD_DISK_REMOVED);
  1137. d->state |= (1<<MD_DISK_FAULTY);
  1138. failed++;
  1139. }
  1140. }
  1141. sb->nr_disks = nr_disks;
  1142. sb->active_disks = active;
  1143. sb->working_disks = working;
  1144. sb->failed_disks = failed;
  1145. sb->spare_disks = spare;
  1146. sb->this_disk = sb->disks[rdev->desc_nr];
  1147. sb->sb_csum = calc_sb_csum(sb);
  1148. }
  1149. /*
  1150. * rdev_size_change for 0.90.0
  1151. */
  1152. static unsigned long long
  1153. super_90_rdev_size_change(mdk_rdev_t *rdev, sector_t num_sectors)
  1154. {
  1155. if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
  1156. return 0; /* component must fit device */
  1157. if (rdev->mddev->bitmap_info.offset)
  1158. return 0; /* can't move bitmap */
  1159. rdev->sb_start = calc_dev_sboffset(rdev->bdev);
  1160. if (!num_sectors || num_sectors > rdev->sb_start)
  1161. num_sectors = rdev->sb_start;
  1162. md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
  1163. rdev->sb_page);
  1164. md_super_wait(rdev->mddev);
  1165. return num_sectors / 2; /* kB for sysfs */
  1166. }
  1167. /*
  1168. * version 1 superblock
  1169. */
  1170. static __le32 calc_sb_1_csum(struct mdp_superblock_1 * sb)
  1171. {
  1172. __le32 disk_csum;
  1173. u32 csum;
  1174. unsigned long long newcsum;
  1175. int size = 256 + le32_to_cpu(sb->max_dev)*2;
  1176. __le32 *isuper = (__le32*)sb;
  1177. int i;
  1178. disk_csum = sb->sb_csum;
  1179. sb->sb_csum = 0;
  1180. newcsum = 0;
  1181. for (i=0; size>=4; size -= 4 )
  1182. newcsum += le32_to_cpu(*isuper++);
  1183. if (size == 2)
  1184. newcsum += le16_to_cpu(*(__le16*) isuper);
  1185. csum = (newcsum & 0xffffffff) + (newcsum >> 32);
  1186. sb->sb_csum = disk_csum;
  1187. return cpu_to_le32(csum);
  1188. }
  1189. static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
  1190. {
  1191. struct mdp_superblock_1 *sb;
  1192. int ret;
  1193. sector_t sb_start;
  1194. char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
  1195. int bmask;
  1196. /*
  1197. * Calculate the position of the superblock in 512byte sectors.
  1198. * It is always aligned to a 4K boundary and
  1199. * depeding on minor_version, it can be:
  1200. * 0: At least 8K, but less than 12K, from end of device
  1201. * 1: At start of device
  1202. * 2: 4K from start of device.
  1203. */
  1204. switch(minor_version) {
  1205. case 0:
  1206. sb_start = rdev->bdev->bd_inode->i_size >> 9;
  1207. sb_start -= 8*2;
  1208. sb_start &= ~(sector_t)(4*2-1);
  1209. break;
  1210. case 1:
  1211. sb_start = 0;
  1212. break;
  1213. case 2:
  1214. sb_start = 8;
  1215. break;
  1216. default:
  1217. return -EINVAL;
  1218. }
  1219. rdev->sb_start = sb_start;
  1220. /* superblock is rarely larger than 1K, but it can be larger,
  1221. * and it is safe to read 4k, so we do that
  1222. */
  1223. ret = read_disk_sb(rdev, 4096);
  1224. if (ret) return ret;
  1225. sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
  1226. if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
  1227. sb->major_version != cpu_to_le32(1) ||
  1228. le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
  1229. le64_to_cpu(sb->super_offset) != rdev->sb_start ||
  1230. (le32_to_cpu(sb->feature_map) & ~MD_FEATURE_ALL) != 0)
  1231. return -EINVAL;
  1232. if (calc_sb_1_csum(sb) != sb->sb_csum) {
  1233. printk("md: invalid superblock checksum on %s\n",
  1234. bdevname(rdev->bdev,b));
  1235. return -EINVAL;
  1236. }
  1237. if (le64_to_cpu(sb->data_size) < 10) {
  1238. printk("md: data_size too small on %s\n",
  1239. bdevname(rdev->bdev,b));
  1240. return -EINVAL;
  1241. }
  1242. rdev->preferred_minor = 0xffff;
  1243. rdev->data_offset = le64_to_cpu(sb->data_offset);
  1244. atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
  1245. rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
  1246. bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
  1247. if (rdev->sb_size & bmask)
  1248. rdev->sb_size = (rdev->sb_size | bmask) + 1;
  1249. if (minor_version
  1250. && rdev->data_offset < sb_start + (rdev->sb_size/512))
  1251. return -EINVAL;
  1252. if (sb->level == cpu_to_le32(LEVEL_MULTIPATH))
  1253. rdev->desc_nr = -1;
  1254. else
  1255. rdev->desc_nr = le32_to_cpu(sb->dev_number);
  1256. if (!refdev) {
  1257. ret = 1;
  1258. } else {
  1259. __u64 ev1, ev2;
  1260. struct mdp_superblock_1 *refsb =
  1261. (struct mdp_superblock_1*)page_address(refdev->sb_page);
  1262. if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 ||
  1263. sb->level != refsb->level ||
  1264. sb->layout != refsb->layout ||
  1265. sb->chunksize != refsb->chunksize) {
  1266. printk(KERN_WARNING "md: %s has strangely different"
  1267. " superblock to %s\n",
  1268. bdevname(rdev->bdev,b),
  1269. bdevname(refdev->bdev,b2));
  1270. return -EINVAL;
  1271. }
  1272. ev1 = le64_to_cpu(sb->events);
  1273. ev2 = le64_to_cpu(refsb->events);
  1274. if (ev1 > ev2)
  1275. ret = 1;
  1276. else
  1277. ret = 0;
  1278. }
  1279. if (minor_version)
  1280. rdev->sectors = (rdev->bdev->bd_inode->i_size >> 9) -
  1281. le64_to_cpu(sb->data_offset);
  1282. else
  1283. rdev->sectors = rdev->sb_start;
  1284. if (rdev->sectors < le64_to_cpu(sb->data_size))
  1285. return -EINVAL;
  1286. rdev->sectors = le64_to_cpu(sb->data_size);
  1287. if (le64_to_cpu(sb->size) > rdev->sectors)
  1288. return -EINVAL;
  1289. return ret;
  1290. }
  1291. static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev)
  1292. {
  1293. struct mdp_superblock_1 *sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
  1294. __u64 ev1 = le64_to_cpu(sb->events);
  1295. rdev->raid_disk = -1;
  1296. clear_bit(Faulty, &rdev->flags);
  1297. clear_bit(In_sync, &rdev->flags);
  1298. clear_bit(WriteMostly, &rdev->flags);
  1299. clear_bit(BarriersNotsupp, &rdev->flags);
  1300. if (mddev->raid_disks == 0) {
  1301. mddev->major_version = 1;
  1302. mddev->patch_version = 0;
  1303. mddev->external = 0;
  1304. mddev->chunk_sectors = le32_to_cpu(sb->chunksize);
  1305. mddev->ctime = le64_to_cpu(sb->ctime) & ((1ULL << 32)-1);
  1306. mddev->utime = le64_to_cpu(sb->utime) & ((1ULL << 32)-1);
  1307. mddev->level = le32_to_cpu(sb->level);
  1308. mddev->clevel[0] = 0;
  1309. mddev->layout = le32_to_cpu(sb->layout);
  1310. mddev->raid_disks = le32_to_cpu(sb->raid_disks);
  1311. mddev->dev_sectors = le64_to_cpu(sb->size);
  1312. mddev->events = ev1;
  1313. mddev->bitmap_info.offset = 0;
  1314. mddev->bitmap_info.default_offset = 1024 >> 9;
  1315. mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
  1316. memcpy(mddev->uuid, sb->set_uuid, 16);
  1317. mddev->max_disks = (4096-256)/2;
  1318. if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_BITMAP_OFFSET) &&
  1319. mddev->bitmap_info.file == NULL )
  1320. mddev->bitmap_info.offset =
  1321. (__s32)le32_to_cpu(sb->bitmap_offset);
  1322. if ((le32_to_cpu(sb->feature_map) & MD_FEATURE_RESHAPE_ACTIVE)) {
  1323. mddev->reshape_position = le64_to_cpu(sb->reshape_position);
  1324. mddev->delta_disks = le32_to_cpu(sb->delta_disks);
  1325. mddev->new_level = le32_to_cpu(sb->new_level);
  1326. mddev->new_layout = le32_to_cpu(sb->new_layout);
  1327. mddev->new_chunk_sectors = le32_to_cpu(sb->new_chunk);
  1328. } else {
  1329. mddev->reshape_position = MaxSector;
  1330. mddev->delta_disks = 0;
  1331. mddev->new_level = mddev->level;
  1332. mddev->new_layout = mddev->layout;
  1333. mddev->new_chunk_sectors = mddev->chunk_sectors;
  1334. }
  1335. } else if (mddev->pers == NULL) {
  1336. /* Insist of good event counter while assembling, except for
  1337. * spares (which don't need an event count) */
  1338. ++ev1;
  1339. if (rdev->desc_nr >= 0 &&
  1340. rdev->desc_nr < le32_to_cpu(sb->max_dev) &&
  1341. le16_to_cpu(sb->dev_roles[rdev->desc_nr]) < 0xfffe)
  1342. if (ev1 < mddev->events)
  1343. return -EINVAL;
  1344. } else if (mddev->bitmap) {
  1345. /* If adding to array with a bitmap, then we can accept an
  1346. * older device, but not too old.
  1347. */
  1348. if (ev1 < mddev->bitmap->events_cleared)
  1349. return 0;
  1350. } else {
  1351. if (ev1 < mddev->events)
  1352. /* just a hot-add of a new device, leave raid_disk at -1 */
  1353. return 0;
  1354. }
  1355. if (mddev->level != LEVEL_MULTIPATH) {
  1356. int role;
  1357. if (rdev->desc_nr < 0 ||
  1358. rdev->desc_nr >= le32_to_cpu(sb->max_dev)) {
  1359. role = 0xffff;
  1360. rdev->desc_nr = -1;
  1361. } else
  1362. role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
  1363. switch(role) {
  1364. case 0xffff: /* spare */
  1365. break;
  1366. case 0xfffe: /* faulty */
  1367. set_bit(Faulty, &rdev->flags);
  1368. break;
  1369. default:
  1370. if ((le32_to_cpu(sb->feature_map) &
  1371. MD_FEATURE_RECOVERY_OFFSET))
  1372. rdev->recovery_offset = le64_to_cpu(sb->recovery_offset);
  1373. else
  1374. set_bit(In_sync, &rdev->flags);
  1375. rdev->raid_disk = role;
  1376. break;
  1377. }
  1378. if (sb->devflags & WriteMostly1)
  1379. set_bit(WriteMostly, &rdev->flags);
  1380. } else /* MULTIPATH are always insync */
  1381. set_bit(In_sync, &rdev->flags);
  1382. return 0;
  1383. }
  1384. static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
  1385. {
  1386. struct mdp_superblock_1 *sb;
  1387. mdk_rdev_t *rdev2;
  1388. int max_dev, i;
  1389. /* make rdev->sb match mddev and rdev data. */
  1390. sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
  1391. sb->feature_map = 0;
  1392. sb->pad0 = 0;
  1393. sb->recovery_offset = cpu_to_le64(0);
  1394. memset(sb->pad1, 0, sizeof(sb->pad1));
  1395. memset(sb->pad2, 0, sizeof(sb->pad2));
  1396. memset(sb->pad3, 0, sizeof(sb->pad3));
  1397. sb->utime = cpu_to_le64((__u64)mddev->utime);
  1398. sb->events = cpu_to_le64(mddev->events);
  1399. if (mddev->in_sync)
  1400. sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
  1401. else
  1402. sb->resync_offset = cpu_to_le64(0);
  1403. sb->cnt_corrected_read = cpu_to_le32(atomic_read(&rdev->corrected_errors));
  1404. sb->raid_disks = cpu_to_le32(mddev->raid_disks);
  1405. sb->size = cpu_to_le64(mddev->dev_sectors);
  1406. sb->chunksize = cpu_to_le32(mddev->chunk_sectors);
  1407. sb->level = cpu_to_le32(mddev->level);
  1408. sb->layout = cpu_to_le32(mddev->layout);
  1409. if (mddev->bitmap && mddev->bitmap_info.file == NULL) {
  1410. sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_info.offset);
  1411. sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
  1412. }
  1413. if (rdev->raid_disk >= 0 &&
  1414. !test_bit(In_sync, &rdev->flags)) {
  1415. sb->feature_map |=
  1416. cpu_to_le32(MD_FEATURE_RECOVERY_OFFSET);
  1417. sb->recovery_offset =
  1418. cpu_to_le64(rdev->recovery_offset);
  1419. }
  1420. if (mddev->reshape_position != MaxSector) {
  1421. sb->feature_map |= cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE);
  1422. sb->reshape_position = cpu_to_le64(mddev->reshape_position);
  1423. sb->new_layout = cpu_to_le32(mddev->new_layout);
  1424. sb->delta_disks = cpu_to_le32(mddev->delta_disks);
  1425. sb->new_level = cpu_to_le32(mddev->new_level);
  1426. sb->new_chunk = cpu_to_le32(mddev->new_chunk_sectors);
  1427. }
  1428. max_dev = 0;
  1429. list_for_each_entry(rdev2, &mddev->disks, same_set)
  1430. if (rdev2->desc_nr+1 > max_dev)
  1431. max_dev = rdev2->desc_nr+1;
  1432. if (max_dev > le32_to_cpu(sb->max_dev)) {
  1433. int bmask;
  1434. sb->max_dev = cpu_to_le32(max_dev);
  1435. rdev->sb_size = max_dev * 2 + 256;
  1436. bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
  1437. if (rdev->sb_size & bmask)
  1438. rdev->sb_size = (rdev->sb_size | bmask) + 1;
  1439. }
  1440. for (i=0; i<max_dev;i++)
  1441. sb->dev_roles[i] = cpu_to_le16(0xfffe);
  1442. list_for_each_entry(rdev2, &mddev->disks, same_set) {
  1443. i = rdev2->desc_nr;
  1444. if (test_bit(Faulty, &rdev2->flags))
  1445. sb->dev_roles[i] = cpu_to_le16(0xfffe);
  1446. else if (test_bit(In_sync, &rdev2->flags))
  1447. sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
  1448. else if (rdev2->raid_disk >= 0)
  1449. sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
  1450. else
  1451. sb->dev_roles[i] = cpu_to_le16(0xffff);
  1452. }
  1453. sb->sb_csum = calc_sb_1_csum(sb);
  1454. }
  1455. static unsigned long long
  1456. super_1_rdev_size_change(mdk_rdev_t *rdev, sector_t num_sectors)
  1457. {
  1458. struct mdp_superblock_1 *sb;
  1459. sector_t max_sectors;
  1460. if (num_sectors && num_sectors < rdev->mddev->dev_sectors)
  1461. return 0; /* component must fit device */
  1462. if (rdev->sb_start < rdev->data_offset) {
  1463. /* minor versions 1 and 2; superblock before data */
  1464. max_sectors = rdev->bdev->bd_inode->i_size >> 9;
  1465. max_sectors -= rdev->data_offset;
  1466. if (!num_sectors || num_sectors > max_sectors)
  1467. num_sectors = max_sectors;
  1468. } else if (rdev->mddev->bitmap_info.offset) {
  1469. /* minor version 0 with bitmap we can't move */
  1470. return 0;
  1471. } else {
  1472. /* minor version 0; superblock after data */
  1473. sector_t sb_start;
  1474. sb_start = (rdev->bdev->bd_inode->i_size >> 9) - 8*2;
  1475. sb_start &= ~(sector_t)(4*2 - 1);
  1476. max_sectors = rdev->sectors + sb_start - rdev->sb_start;
  1477. if (!num_sectors || num_sectors > max_sectors)
  1478. num_sectors = max_sectors;
  1479. rdev->sb_start = sb_start;
  1480. }
  1481. sb = (struct mdp_superblock_1 *) page_address(rdev->sb_page);
  1482. sb->data_size = cpu_to_le64(num_sectors);
  1483. sb->super_offset = rdev->sb_start;
  1484. sb->sb_csum = calc_sb_1_csum(sb);
  1485. md_super_write(rdev->mddev, rdev, rdev->sb_start, rdev->sb_size,
  1486. rdev->sb_page);
  1487. md_super_wait(rdev->mddev);
  1488. return num_sectors / 2; /* kB for sysfs */
  1489. }
  1490. static struct super_type super_types[] = {
  1491. [0] = {
  1492. .name = "0.90.0",
  1493. .owner = THIS_MODULE,
  1494. .load_super = super_90_load,
  1495. .validate_super = super_90_validate,
  1496. .sync_super = super_90_sync,
  1497. .rdev_size_change = super_90_rdev_size_change,
  1498. },
  1499. [1] = {
  1500. .name = "md-1",
  1501. .owner = THIS_MODULE,
  1502. .load_super = super_1_load,
  1503. .validate_super = super_1_validate,
  1504. .sync_super = super_1_sync,
  1505. .rdev_size_change = super_1_rdev_size_change,
  1506. },
  1507. };
  1508. static int match_mddev_units(mddev_t *mddev1, mddev_t *mddev2)
  1509. {
  1510. mdk_rdev_t *rdev, *rdev2;
  1511. rcu_read_lock();
  1512. rdev_for_each_rcu(rdev, mddev1)
  1513. rdev_for_each_rcu(rdev2, mddev2)
  1514. if (rdev->bdev->bd_contains ==
  1515. rdev2->bdev->bd_contains) {
  1516. rcu_read_unlock();
  1517. return 1;
  1518. }
  1519. rcu_read_unlock();
  1520. return 0;
  1521. }
  1522. static LIST_HEAD(pending_raid_disks);
  1523. /*
  1524. * Try to register data integrity profile for an mddev
  1525. *
  1526. * This is called when an array is started and after a disk has been kicked
  1527. * from the array. It only succeeds if all working and active component devices
  1528. * are integrity capable with matching profiles.
  1529. */
  1530. int md_integrity_register(mddev_t *mddev)
  1531. {
  1532. mdk_rdev_t *rdev, *reference = NULL;
  1533. if (list_empty(&mddev->disks))
  1534. return 0; /* nothing to do */
  1535. if (blk_get_integrity(mddev->gendisk))
  1536. return 0; /* already registered */
  1537. list_for_each_entry(rdev, &mddev->disks, same_set) {
  1538. /* skip spares and non-functional disks */
  1539. if (test_bit(Faulty, &rdev->flags))
  1540. continue;
  1541. if (rdev->raid_disk < 0)
  1542. continue;
  1543. /*
  1544. * If at least one rdev is not integrity capable, we can not
  1545. * enable data integrity for the md device.
  1546. */
  1547. if (!bdev_get_integrity(rdev->bdev))
  1548. return -EINVAL;
  1549. if (!reference) {
  1550. /* Use the first rdev as the reference */
  1551. reference = rdev;
  1552. continue;
  1553. }
  1554. /* does this rdev's profile match the reference profile? */
  1555. if (blk_integrity_compare(reference->bdev->bd_disk,
  1556. rdev->bdev->bd_disk) < 0)
  1557. return -EINVAL;
  1558. }
  1559. /*
  1560. * All component devices are integrity capable and have matching
  1561. * profiles, register the common profile for the md device.
  1562. */
  1563. if (blk_integrity_register(mddev->gendisk,
  1564. bdev_get_integrity(reference->bdev)) != 0) {
  1565. printk(KERN_ERR "md: failed to register integrity for %s\n",
  1566. mdname(mddev));
  1567. return -EINVAL;
  1568. }
  1569. printk(KERN_NOTICE "md: data integrity on %s enabled\n",
  1570. mdname(mddev));
  1571. return 0;
  1572. }
  1573. EXPORT_SYMBOL(md_integrity_register);
  1574. /* Disable data integrity if non-capable/non-matching disk is being added */
  1575. void md_integrity_add_rdev(mdk_rdev_t *rdev, mddev_t *mddev)
  1576. {
  1577. struct blk_integrity *bi_rdev = bdev_get_integrity(rdev->bdev);
  1578. struct blk_integrity *bi_mddev = blk_get_integrity(mddev->gendisk);
  1579. if (!bi_mddev) /* nothing to do */
  1580. return;
  1581. if (rdev->raid_disk < 0) /* skip spares */
  1582. return;
  1583. if (bi_rdev && blk_integrity_compare(mddev->gendisk,
  1584. rdev->bdev->bd_disk) >= 0)
  1585. return;
  1586. printk(KERN_NOTICE "disabling data integrity on %s\n", mdname(mddev));
  1587. blk_integrity_unregister(mddev->gendisk);
  1588. }
  1589. EXPORT_SYMBOL(md_integrity_add_rdev);
  1590. static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
  1591. {
  1592. char b[BDEVNAME_SIZE];
  1593. struct kobject *ko;
  1594. char *s;
  1595. int err;
  1596. if (rdev->mddev) {
  1597. MD_BUG();
  1598. return -EINVAL;
  1599. }
  1600. /* prevent duplicates */
  1601. if (find_rdev(mddev, rdev->bdev->bd_dev))
  1602. return -EEXIST;
  1603. /* make sure rdev->sectors exceeds mddev->dev_sectors */
  1604. if (rdev->sectors && (mddev->dev_sectors == 0 ||
  1605. rdev->sectors < mddev->dev_sectors)) {
  1606. if (mddev->pers) {
  1607. /* Cannot change size, so fail
  1608. * If mddev->level <= 0, then we don't care
  1609. * about aligning sizes (e.g. linear)
  1610. */
  1611. if (mddev->level > 0)
  1612. return -ENOSPC;
  1613. } else
  1614. mddev->dev_sectors = rdev->sectors;
  1615. }
  1616. /* Verify rdev->desc_nr is unique.
  1617. * If it is -1, assign a free number, else
  1618. * check number is not in use
  1619. */
  1620. if (rdev->desc_nr < 0) {
  1621. int choice = 0;
  1622. if (mddev->pers) choice = mddev->raid_disks;
  1623. while (find_rdev_nr(mddev, choice))
  1624. choice++;
  1625. rdev->desc_nr = choice;
  1626. } else {
  1627. if (find_rdev_nr(mddev, rdev->desc_nr))
  1628. return -EBUSY;
  1629. }
  1630. if (mddev->max_disks && rdev->desc_nr >= mddev->max_disks) {
  1631. printk(KERN_WARNING "md: %s: array is limited to %d devices\n",
  1632. mdname(mddev), mddev->max_disks);
  1633. return -EBUSY;
  1634. }
  1635. bdevname(rdev->bdev,b);
  1636. while ( (s=strchr(b, '/')) != NULL)
  1637. *s = '!';
  1638. rdev->mddev = mddev;
  1639. printk(KERN_INFO "md: bind<%s>\n", b);
  1640. if ((err = kobject_add(&rdev->kobj, &mddev->kobj, "dev-%s", b)))
  1641. goto fail;
  1642. ko = &part_to_dev(rdev->bdev->bd_part)->kobj;
  1643. if (sysfs_create_link(&rdev->kobj, ko, "block"))
  1644. /* failure here is OK */;
  1645. rdev->sysfs_state = sysfs_get_dirent_safe(rdev->kobj.sd, "state");
  1646. list_add_rcu(&rdev->same_set, &mddev->disks);
  1647. bd_claim_by_disk(rdev->bdev, rdev->bdev->bd_holder, mddev->gendisk);
  1648. /* May as well allow recovery to be retried once */
  1649. mddev->recovery_disabled = 0;
  1650. return 0;
  1651. fail:
  1652. printk(KERN_WARNING "md: failed to register dev-%s for %s\n",
  1653. b, mdname(mddev));
  1654. return err;
  1655. }
  1656. static void md_delayed_delete(struct work_struct *ws)
  1657. {
  1658. mdk_rdev_t *rdev = container_of(ws, mdk_rdev_t, del_work);
  1659. kobject_del(&rdev->kobj);
  1660. kobject_put(&rdev->kobj);
  1661. }
  1662. static void unbind_rdev_from_array(mdk_rdev_t * rdev)
  1663. {
  1664. char b[BDEVNAME_SIZE];
  1665. if (!rdev->mddev) {
  1666. MD_BUG();
  1667. return;
  1668. }
  1669. bd_release_from_disk(rdev->bdev, rdev->mddev->gendisk);
  1670. list_del_rcu(&rdev->same_set);
  1671. printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
  1672. rdev->mddev = NULL;
  1673. sysfs_remove_link(&rdev->kobj, "block");
  1674. sysfs_put(rdev->sysfs_state);
  1675. rdev->sysfs_state = NULL;
  1676. /* We need to delay this, otherwise we can deadlock when
  1677. * writing to 'remove' to "dev/state". We also need
  1678. * to delay it due to rcu usage.
  1679. */
  1680. synchronize_rcu();
  1681. INIT_WORK(&rdev->del_work, md_delayed_delete);
  1682. kobject_get(&rdev->kobj);
  1683. schedule_work(&rdev->del_work);
  1684. }
  1685. /*
  1686. * prevent the device from being mounted, repartitioned or
  1687. * otherwise reused by a RAID array (or any other kernel
  1688. * subsystem), by bd_claiming the device.
  1689. */
  1690. static int lock_rdev(mdk_rdev_t *rdev, dev_t dev, int shared)
  1691. {
  1692. int err = 0;
  1693. struct block_device *bdev;
  1694. char b[BDEVNAME_SIZE];
  1695. bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE);
  1696. if (IS_ERR(bdev)) {
  1697. printk(KERN_ERR "md: could not open %s.\n",
  1698. __bdevname(dev, b));
  1699. return PTR_ERR(bdev);
  1700. }
  1701. err = bd_claim(bdev, shared ? (mdk_rdev_t *)lock_rdev : rdev);
  1702. if (err) {
  1703. printk(KERN_ERR "md: could not bd_claim %s.\n",
  1704. bdevname(bdev, b));
  1705. blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
  1706. return err;
  1707. }
  1708. if (!shared)
  1709. set_bit(AllReserved, &rdev->flags);
  1710. rdev->bdev = bdev;
  1711. return err;
  1712. }
  1713. static void unlock_rdev(mdk_rdev_t *rdev)
  1714. {
  1715. struct block_device *bdev = rdev->bdev;
  1716. rdev->bdev = NULL;
  1717. if (!bdev)
  1718. MD_BUG();
  1719. bd_release(bdev);
  1720. blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
  1721. }
  1722. void md_autodetect_dev(dev_t dev);
  1723. static void export_rdev(mdk_rdev_t * rdev)
  1724. {
  1725. char b[BDEVNAME_SIZE];
  1726. printk(KERN_INFO "md: export_rdev(%s)\n",
  1727. bdevname(rdev->bdev,b));
  1728. if (rdev->mddev)
  1729. MD_BUG();
  1730. free_disk_sb(rdev);
  1731. #ifndef MODULE
  1732. if (test_bit(AutoDetected, &rdev->flags))
  1733. md_autodetect_dev(rdev->bdev->bd_dev);
  1734. #endif
  1735. unlock_rdev(rdev);
  1736. kobject_put(&rdev->kobj);
  1737. }
  1738. static void kick_rdev_from_array(mdk_rdev_t * rdev)
  1739. {
  1740. unbind_rdev_from_array(rdev);
  1741. export_rdev(rdev);
  1742. }
  1743. static void export_array(mddev_t *mddev)
  1744. {
  1745. mdk_rdev_t *rdev, *tmp;
  1746. rdev_for_each(rdev, tmp, mddev) {
  1747. if (!rdev->mddev) {
  1748. MD_BUG();
  1749. continue;
  1750. }
  1751. kick_rdev_from_array(rdev);
  1752. }
  1753. if (!list_empty(&mddev->disks))
  1754. MD_BUG();
  1755. mddev->raid_disks = 0;
  1756. mddev->major_version = 0;
  1757. }
  1758. static void print_desc(mdp_disk_t *desc)
  1759. {
  1760. printk(" DISK<N:%d,(%d,%d),R:%d,S:%d>\n", desc->number,
  1761. desc->major,desc->minor,desc->raid_disk,desc->state);
  1762. }
  1763. static void print_sb_90(mdp_super_t *sb)
  1764. {
  1765. int i;
  1766. printk(KERN_INFO
  1767. "md: SB: (V:%d.%d.%d) ID:<%08x.%08x.%08x.%08x> CT:%08x\n",
  1768. sb->major_version, sb->minor_version, sb->patch_version,
  1769. sb->set_uuid0, sb->set_uuid1, sb->set_uuid2, sb->set_uuid3,
  1770. sb->ctime);
  1771. printk(KERN_INFO "md: L%d S%08d ND:%d RD:%d md%d LO:%d CS:%d\n",
  1772. sb->level, sb->size, sb->nr_disks, sb->raid_disks,
  1773. sb->md_minor, sb->layout, sb->chunk_size);
  1774. printk(KERN_INFO "md: UT:%08x ST:%d AD:%d WD:%d"
  1775. " FD:%d SD:%d CSUM:%08x E:%08lx\n",
  1776. sb->utime, sb->state, sb->active_disks, sb->working_disks,
  1777. sb->failed_disks, sb->spare_disks,
  1778. sb->sb_csum, (unsigned long)sb->events_lo);
  1779. printk(KERN_INFO);
  1780. for (i = 0; i < MD_SB_DISKS; i++) {
  1781. mdp_disk_t *desc;
  1782. desc = sb->disks + i;
  1783. if (desc->number || desc->major || desc->minor ||
  1784. desc->raid_disk || (desc->state && (desc->state != 4))) {
  1785. printk(" D %2d: ", i);
  1786. print_desc(desc);
  1787. }
  1788. }
  1789. printk(KERN_INFO "md: THIS: ");
  1790. print_desc(&sb->this_disk);
  1791. }
  1792. static void print_sb_1(struct mdp_superblock_1 *sb)
  1793. {
  1794. __u8 *uuid;
  1795. uuid = sb->set_uuid;
  1796. printk(KERN_INFO
  1797. "md: SB: (V:%u) (F:0x%08x) Array-ID:<%pU>\n"
  1798. "md: Name: \"%s\" CT:%llu\n",
  1799. le32_to_cpu(sb->major_version),
  1800. le32_to_cpu(sb->feature_map),
  1801. uuid,
  1802. sb->set_name,
  1803. (unsigned long long)le64_to_cpu(sb->ctime)
  1804. & MD_SUPERBLOCK_1_TIME_SEC_MASK);
  1805. uuid = sb->device_uuid;
  1806. printk(KERN_INFO
  1807. "md: L%u SZ%llu RD:%u LO:%u CS:%u DO:%llu DS:%llu SO:%llu"
  1808. " RO:%llu\n"
  1809. "md: Dev:%08x UUID: %pU\n"
  1810. "md: (F:0x%08x) UT:%llu Events:%llu ResyncOffset:%llu CSUM:0x%08x\n"
  1811. "md: (MaxDev:%u) \n",
  1812. le32_to_cpu(sb->level),
  1813. (unsigned long long)le64_to_cpu(sb->size),
  1814. le32_to_cpu(sb->raid_disks),
  1815. le32_to_cpu(sb->layout),
  1816. le32_to_cpu(sb->chunksize),
  1817. (unsigned long long)le64_to_cpu(sb->data_offset),
  1818. (unsigned long long)le64_to_cpu(sb->data_size),
  1819. (unsigned long long)le64_to_cpu(sb->super_offset),
  1820. (unsigned long long)le64_to_cpu(sb->recovery_offset),
  1821. le32_to_cpu(sb->dev_number),
  1822. uuid,
  1823. sb->devflags,
  1824. (unsigned long long)le64_to_cpu(sb->utime) & MD_SUPERBLOCK_1_TIME_SEC_MASK,
  1825. (unsigned long long)le64_to_cpu(sb->events),
  1826. (unsigned long long)le64_to_cpu(sb->resync_offset),
  1827. le32_to_cpu(sb->sb_csum),
  1828. le32_to_cpu(sb->max_dev)
  1829. );
  1830. }
  1831. static void print_rdev(mdk_rdev_t *rdev, int major_version)
  1832. {
  1833. char b[BDEVNAME_SIZE];
  1834. printk(KERN_INFO "md: rdev %s, Sect:%08llu F:%d S:%d DN:%u\n",
  1835. bdevname(rdev->bdev, b), (unsigned long long)rdev->sectors,
  1836. test_bit(Faulty, &rdev->flags), test_bit(In_sync, &rdev->flags),
  1837. rdev->desc_nr);
  1838. if (rdev->sb_loaded) {
  1839. printk(KERN_INFO "md: rdev superblock (MJ:%d):\n", major_version);
  1840. switch (major_version) {
  1841. case 0:
  1842. print_sb_90((mdp_super_t*)page_address(rdev->sb_page));
  1843. break;
  1844. case 1:
  1845. print_sb_1((struct mdp_superblock_1 *)page_address(rdev->sb_page));
  1846. break;
  1847. }
  1848. } else
  1849. printk(KERN_INFO "md: no rdev superblock!\n");
  1850. }
  1851. static void md_print_devices(void)
  1852. {
  1853. struct list_head *tmp;
  1854. mdk_rdev_t *rdev;
  1855. mddev_t *mddev;
  1856. char b[BDEVNAME_SIZE];
  1857. printk("\n");
  1858. printk("md: **********************************\n");
  1859. printk("md: * <COMPLETE RAID STATE PRINTOUT> *\n");
  1860. printk("md: **********************************\n");
  1861. for_each_mddev(mddev, tmp) {
  1862. if (mddev->bitmap)
  1863. bitmap_print_sb(mddev->bitmap);
  1864. else
  1865. printk("%s: ", mdname(mddev));
  1866. list_for_each_entry(rdev, &mddev->disks, same_set)
  1867. printk("<%s>", bdevname(rdev->bdev,b));
  1868. printk("\n");
  1869. list_for_each_entry(rdev, &mddev->disks, same_set)
  1870. print_rdev(rdev, mddev->major_version);
  1871. }
  1872. printk("md: **********************************\n");
  1873. printk("\n");
  1874. }
  1875. static void sync_sbs(mddev_t * mddev, int nospares)
  1876. {
  1877. /* Update each superblock (in-memory image), but
  1878. * if we are allowed to, skip spares which already
  1879. * have the right event counter, or have one earlier
  1880. * (which would mean they aren't being marked as dirty
  1881. * with the rest of the array)
  1882. */
  1883. mdk_rdev_t *rdev;
  1884. list_for_each_entry(rdev, &mddev->disks, same_set) {
  1885. if (rdev->sb_events == mddev->events ||
  1886. (nospares &&
  1887. rdev->raid_disk < 0 &&
  1888. rdev->sb_events+1 == mddev->events)) {
  1889. /* Don't update this superblock */
  1890. rdev->sb_loaded = 2;
  1891. } else {
  1892. super_types[mddev->major_version].
  1893. sync_super(mddev, rdev);
  1894. rdev->sb_loaded = 1;
  1895. }
  1896. }
  1897. }
  1898. static void md_update_sb(mddev_t * mddev, int force_change)
  1899. {
  1900. mdk_rdev_t *rdev;
  1901. int sync_req;
  1902. int nospares = 0;
  1903. repeat:
  1904. /* First make sure individual recovery_offsets are correct */
  1905. list_for_each_entry(rdev, &mddev->disks, same_set) {
  1906. if (rdev->raid_disk >= 0 &&
  1907. mddev->delta_disks >= 0 &&
  1908. !test_bit(In_sync, &rdev->flags) &&
  1909. mddev->curr_resync_completed > rdev->recovery_offset)
  1910. rdev->recovery_offset = mddev->curr_resync_completed;
  1911. }
  1912. if (!mddev->persistent) {
  1913. clear_bit(MD_CHANGE_CLEAN, &mddev->flags);
  1914. clear_bit(MD_CHANGE_DEVS, &mddev->flags);
  1915. wake_up(&mddev->sb_wait);
  1916. return;
  1917. }
  1918. spin_lock_irq(&mddev->write_lock);
  1919. mddev->utime = get_seconds();
  1920. if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags))
  1921. force_change = 1;
  1922. if (test_and_clear_bit(MD_CHANGE_CLEAN, &mddev->flags))
  1923. /* just a clean<-> dirty transition, possibly leave spares alone,
  1924. * though if events isn't the right even/odd, we will have to do
  1925. * spares after all
  1926. */
  1927. nospares = 1;
  1928. if (force_change)
  1929. nospares = 0;
  1930. if (mddev->degraded)
  1931. /* If the array is degraded, then skipping spares is both
  1932. * dangerous and fairly pointless.
  1933. * Dangerous because a device that was removed from the array
  1934. * might have a event_count that still looks up-to-date,
  1935. * so it can be re-added without a resync.
  1936. * Pointless because if there are any spares to skip,
  1937. * then a recovery will happen and soon that array won't
  1938. * be degraded any more and the spare can go back to sleep then.
  1939. */
  1940. nospares = 0;
  1941. sync_req = mddev->in_sync;
  1942. /* If this is just a dirty<->clean transition, and the array is clean
  1943. * and 'events' is odd, we can roll back to the previous clean state */
  1944. if (nospares
  1945. && (mddev->in_sync && mddev->recovery_cp == MaxSector)
  1946. && mddev->can_decrease_events
  1947. && mddev->events != 1) {
  1948. mddev->events--;
  1949. mddev->can_decrease_events = 0;
  1950. } else {
  1951. /* otherwise we have to go forward and ... */
  1952. mddev->events ++;
  1953. mddev->can_decrease_events = nospares;
  1954. }
  1955. if (!mddev->events) {
  1956. /*
  1957. * oops, this 64-bit counter should never wrap.
  1958. * Either we are in around ~1 trillion A.C., assuming
  1959. * 1 reboot per second, or we have a bug:
  1960. */
  1961. MD_BUG();
  1962. mddev->events --;
  1963. }
  1964. sync_sbs(mddev, nospares);
  1965. spin_unlock_irq(&mddev->write_lock);
  1966. dprintk(KERN_INFO
  1967. "md: updating %s RAID superblock on device (in sync %d)\n",
  1968. mdname(mddev),mddev->in_sync);
  1969. bitmap_update_sb(mddev->bitmap);
  1970. list_for_each_entry(rdev, &mddev->disks, same_set) {
  1971. char b[BDEVNAME_SIZE];
  1972. dprintk(KERN_INFO "md: ");
  1973. if (rdev->sb_loaded != 1)
  1974. continue; /* no noise on spare devices */
  1975. if (test_bit(Faulty, &rdev->flags))
  1976. dprintk("(skipping faulty ");
  1977. dprintk("%s ", bdevname(rdev->bdev,b));
  1978. if (!test_bit(Faulty, &rdev->flags)) {
  1979. md_super_write(mddev,rdev,
  1980. rdev->sb_start, rdev->sb_size,
  1981. rdev->sb_page);
  1982. dprintk(KERN_INFO "(write) %s's sb offset: %llu\n",
  1983. bdevname(rdev->bdev,b),
  1984. (unsigned long long)rdev->sb_start);
  1985. rdev->sb_events = mddev->events;
  1986. } else
  1987. dprintk(")\n");
  1988. if (mddev->level == LEVEL_MULTIPATH)
  1989. /* only need to write one superblock... */
  1990. break;
  1991. }
  1992. md_super_wait(mddev);
  1993. /* if there was a failure, MD_CHANGE_DEVS was set, and we re-write super */
  1994. spin_lock_irq(&mddev->write_lock);
  1995. if (mddev->in_sync != sync_req ||
  1996. test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
  1997. /* have to write it out again */
  1998. spin_unlock_irq(&mddev->write_lock);
  1999. goto repeat;
  2000. }
  2001. clear_bit(MD_CHANGE_PENDING, &mddev->flags);
  2002. spin_unlock_irq(&mddev->write_lock);
  2003. wake_up(&mddev->sb_wait);
  2004. if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
  2005. sysfs_notify(&mddev->kobj, NULL, "sync_completed");
  2006. }
  2007. /* words written to sysfs files may, or may not, be \n terminated.
  2008. * We want to accept with case. For this we use cmd_match.
  2009. */
  2010. static int cmd_match(const char *cmd, const char *str)
  2011. {
  2012. /* See if cmd, written into a sysfs file, matches
  2013. * str. They must either be the same, or cmd can
  2014. * have a trailing newline
  2015. */
  2016. while (*cmd && *str && *cmd == *str) {
  2017. cmd++;
  2018. str++;
  2019. }
  2020. if (*cmd == '\n')
  2021. cmd++;
  2022. if (*str || *cmd)
  2023. return 0;
  2024. return 1;
  2025. }
  2026. struct rdev_sysfs_entry {
  2027. struct attribute attr;
  2028. ssize_t (*show)(mdk_rdev_t *, char *);
  2029. ssize_t (*store)(mdk_rdev_t *, const char *, size_t);
  2030. };
  2031. static ssize_t
  2032. state_show(mdk_rdev_t *rdev, char *page)
  2033. {
  2034. char *sep = "";
  2035. size_t len = 0;
  2036. if (test_bit(Faulty, &rdev->flags)) {
  2037. len+= sprintf(page+len, "%sfaulty",sep);
  2038. sep = ",";
  2039. }
  2040. if (test_bit(In_sync, &rdev->flags)) {
  2041. len += sprintf(page+len, "%sin_sync",sep);
  2042. sep = ",";
  2043. }
  2044. if (test_bit(WriteMostly, &rdev->flags)) {
  2045. len += sprintf(page+len, "%swrite_mostly",sep);
  2046. sep = ",";
  2047. }
  2048. if (test_bit(Blocked, &rdev->flags)) {
  2049. len += sprintf(page+len, "%sblocked", sep);
  2050. sep = ",";
  2051. }
  2052. if (!test_bit(Faulty, &rdev->flags) &&
  2053. !test_bit(In_sync, &rdev->flags)) {
  2054. len += sprintf(page+len, "%sspare", sep);
  2055. sep = ",";
  2056. }
  2057. return len+sprintf(page+len, "\n");
  2058. }
  2059. static ssize_t
  2060. state_store(mdk_rdev_t *rdev, const char *buf, size_t len)
  2061. {
  2062. /* can write
  2063. * faulty - simulates and error
  2064. * remove - disconnects the device
  2065. * writemostly - sets write_mostly
  2066. * -writemostly - clears write_mostly
  2067. * blocked - sets the Blocked flag
  2068. * -blocked - clears the Blocked flag
  2069. * insync - sets Insync providing device isn't active
  2070. */
  2071. int err = -EINVAL;
  2072. if (cmd_match(buf, "faulty") && rdev->mddev->pers) {
  2073. md_error(rdev->mddev, rdev);
  2074. err = 0;
  2075. } else if (cmd_match(buf, "remove")) {
  2076. if (rdev->raid_disk >= 0)
  2077. err = -EBUSY;
  2078. else {
  2079. mddev_t *mddev = rdev->mddev;
  2080. kick_rdev_from_array(rdev);
  2081. if (mddev->pers)
  2082. md_update_sb(mddev, 1);
  2083. md_new_event(mddev);
  2084. err = 0;
  2085. }
  2086. } else if (cmd_match(buf, "writemostly")) {
  2087. set_bit(WriteMostly, &rdev->flags);
  2088. err = 0;
  2089. } else if (cmd_match(buf, "-writemostly")) {
  2090. clear_bit(WriteMostly, &rdev->flags);
  2091. err = 0;
  2092. } else if (cmd_match(buf, "blocked")) {
  2093. set_bit(Blocked, &rdev->flags);
  2094. err = 0;
  2095. } else if (cmd_match(buf, "-blocked")) {
  2096. clear_bit(Blocked, &rdev->flags);
  2097. wake_up(&rdev->blocked_wait);
  2098. set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
  2099. md_wakeup_thread(rdev->mddev->thread);
  2100. err = 0;
  2101. } else if (cmd_match(buf, "insync") && rdev->raid_disk == -1) {
  2102. set_bit(In_sync, &rdev->flags);
  2103. err = 0;
  2104. }
  2105. if (!err)
  2106. sysfs_notify_dirent_safe(rdev->sysfs_state);
  2107. return err ? err : len;
  2108. }
  2109. static struct rdev_sysfs_entry rdev_state =
  2110. __ATTR(state, S_IRUGO|S_IWUSR, state_show, state_store);
  2111. static ssize_t
  2112. errors_show(mdk_rdev_t *rdev, char *page)
  2113. {
  2114. return sprintf(page, "%d\n", atomic_read(&rdev->corrected_errors));
  2115. }
  2116. static ssize_t
  2117. errors_store(mdk_rdev_t *rdev, const char *buf, size_t len)
  2118. {
  2119. char *e;
  2120. unsigned long n = simple_strtoul(buf, &e, 10);
  2121. if (*buf && (*e == 0 || *e == '\n')) {
  2122. atomic_set(&rdev->corrected_errors, n);
  2123. return len;
  2124. }
  2125. return -EINVAL;
  2126. }
  2127. static struct rdev_sysfs_entry rdev_errors =
  2128. __ATTR(errors, S_IRUGO|S_IWUSR, errors_show, errors_store);
  2129. static ssize_t
  2130. slot_show(mdk_rdev_t *rdev, char *page)
  2131. {
  2132. if (rdev->raid_disk < 0)
  2133. return sprintf(page, "none\n");
  2134. else
  2135. return sprintf(page, "%d\n", rdev->raid_disk);
  2136. }
  2137. static ssize_t
  2138. slot_store(mdk_rdev_t *rdev, const char *buf, size_t len)
  2139. {
  2140. char *e;
  2141. int err;
  2142. char nm[20];
  2143. int slot = simple_strtoul(buf, &e, 10);
  2144. if (strncmp(buf, "none", 4)==0)
  2145. slot = -1;
  2146. else if (e==buf || (*e && *e!= '\n'))
  2147. return -EINVAL;
  2148. if (rdev->mddev->pers && slot == -1) {
  2149. /* Setting 'slot' on an active array requires also
  2150. * updating the 'rd%d' link, and communicating
  2151. * with the personality with ->hot_*_disk.
  2152. * For now we only support removing
  2153. * failed/spare devices. This normally happens automatically,
  2154. * but not when the metadata is externally managed.
  2155. */
  2156. if (rdev->raid_disk == -1)
  2157. return -EEXIST;
  2158. /* personality does all needed checks */
  2159. if (rdev->mddev->pers->hot_add_disk == NULL)
  2160. return -EINVAL;
  2161. err = rdev->mddev->pers->
  2162. hot_remove_disk(rdev->mddev, rdev->raid_disk);
  2163. if (err)
  2164. return err;
  2165. sprintf(nm, "rd%d", rdev->raid_disk);
  2166. sysfs_remove_link(&rdev->mddev->kobj, nm);
  2167. rdev->raid_disk = -1;
  2168. set_bit(MD_RECOVERY_NEEDED, &rdev->mddev->recovery);
  2169. md_wakeup_thread(rdev->mddev->thread);
  2170. } else if (rdev->mddev->pers) {
  2171. mdk_rdev_t *rdev2;
  2172. /* Activating a spare .. or possibly reactivating
  2173. * if we ever get bitmaps working here.
  2174. */
  2175. if (rdev->raid_disk != -1)
  2176. return -EBUSY;
  2177. if (rdev->mddev->pers->hot_add_disk == NULL)
  2178. return -EINVAL;
  2179. list_for_each_entry(rdev2, &rdev->mddev->disks, same_set)
  2180. if (rdev2->raid_disk == slot)
  2181. return -EEXIST;
  2182. rdev->raid_disk = slot;
  2183. if (test_bit(In_sync, &rdev->flags))
  2184. rdev->saved_raid_disk = slot;
  2185. else
  2186. rdev->saved_raid_disk = -1;
  2187. err = rdev->mddev->pers->
  2188. hot_add_disk(rdev->mddev, rdev);
  2189. if (err) {
  2190. rdev->raid_disk = -1;
  2191. return err;
  2192. } else
  2193. sysfs_notify_dirent_safe(rdev->sysfs_state);
  2194. sprintf(nm, "rd%d", rdev->raid_disk);
  2195. if (sysfs_create_link(&rdev->mddev->kobj, &rdev->kobj, nm))
  2196. /* failure here is OK */;
  2197. /* don't wakeup anyone, leave that to userspace. */
  2198. } else {
  2199. if (slot >= rdev->mddev->raid_disks)
  2200. return -ENOSPC;
  2201. rdev->raid_disk = slot;
  2202. /* assume it is working */
  2203. clear_bit(Faulty, &rdev->flags);
  2204. clear_bit(WriteMostly, &rdev->flags);
  2205. set_bit(In_sync, &rdev->flags);
  2206. sysfs_notify_dirent_safe(rdev->sysfs_state);
  2207. }
  2208. return len;
  2209. }
  2210. static struct rdev_sysfs_entry rdev_slot =
  2211. __ATTR(slot, S_IRUGO|S_IWUSR, slot_show, slot_store);
  2212. static ssize_t
  2213. offset_show(mdk_rdev_t *rdev, char *page)
  2214. {
  2215. return sprintf(page, "%llu\n", (unsigned long long)rdev->data_offset);
  2216. }
  2217. static ssize_t
  2218. offset_store(mdk_rdev_t *rdev, const char *buf, size_t len)
  2219. {
  2220. char *e;
  2221. unsigned long long offset = simple_strtoull(buf, &e, 10);
  2222. if (e==buf || (*e && *e != '\n'))
  2223. return -EINVAL;
  2224. if (rdev->mddev->pers && rdev->raid_disk >= 0)
  2225. return -EBUSY;
  2226. if (rdev->sectors && rdev->mddev->external)
  2227. /* Must set offset before size, so overlap checks
  2228. * can be sane */
  2229. return -EBUSY;
  2230. rdev->data_offset = offset;
  2231. return len;
  2232. }
  2233. static struct rdev_sysfs_entry rdev_offset =
  2234. __ATTR(offset, S_IRUGO|S_IWUSR, offset_show, offset_store);
  2235. static ssize_t
  2236. rdev_size_show(mdk_rdev_t *rdev, char *page)
  2237. {
  2238. return sprintf(page, "%llu\n", (unsigned long long)rdev->sectors / 2);
  2239. }
  2240. static int overlaps(sector_t s1, sector_t l1, sector_t s2, sector_t l2)
  2241. {
  2242. /* check if two start/length pairs overlap */
  2243. if (s1+l1 <= s2)
  2244. return 0;
  2245. if (s2+l2 <= s1)
  2246. return 0;
  2247. return 1;
  2248. }
  2249. static int strict_blocks_to_sectors(const char *buf, sector_t *sectors)
  2250. {
  2251. unsigned long long blocks;
  2252. sector_t new;
  2253. if (strict_strtoull(buf, 10, &blocks) < 0)
  2254. return -EINVAL;
  2255. if (blocks & 1ULL << (8 * sizeof(blocks) - 1))
  2256. return -EINVAL; /* sector conversion overflow */
  2257. new = blocks * 2;
  2258. if (new != blocks * 2)
  2259. return -EINVAL; /* unsigned long long to sector_t overflow */
  2260. *sectors = new;
  2261. return 0;
  2262. }
  2263. static ssize_t
  2264. rdev_size_store(mdk_rdev_t *rdev, const char *buf, size_t len)
  2265. {
  2266. mddev_t *my_mddev = rdev->mddev;
  2267. sector_t oldsectors = rdev->sectors;
  2268. sector_t sectors;
  2269. if (strict_blocks_to_sectors(buf, &sectors) < 0)
  2270. return -EINVAL;
  2271. if (my_mddev->pers && rdev->raid_disk >= 0) {
  2272. if (my_mddev->persistent) {
  2273. sectors = super_types[my_mddev->major_version].
  2274. rdev_size_change(rdev, sectors);
  2275. if (!sectors)
  2276. return -EBUSY;
  2277. } else if (!sectors)
  2278. sectors = (rdev->bdev->bd_inode->i_size >> 9) -
  2279. rdev->data_offset;
  2280. }
  2281. if (sectors < my_mddev->dev_sectors)
  2282. return -EINVAL; /* component must fit device */
  2283. rdev->sectors = sectors;
  2284. if (sectors > oldsectors && my_mddev->external) {
  2285. /* need to check that all other rdevs with the same ->bdev
  2286. * do not overlap. We need to unlock the mddev to avoid
  2287. * a deadlock. We have already changed rdev->sectors, and if
  2288. * we have to change it back, we will have the lock again.
  2289. */
  2290. mddev_t *mddev;
  2291. int overlap = 0;
  2292. struct list_head *tmp;
  2293. mddev_unlock(my_mddev);
  2294. for_each_mddev(mddev, tmp) {
  2295. mdk_rdev_t *rdev2;
  2296. mddev_lock(mddev);
  2297. list_for_each_entry(rdev2, &mddev->disks, same_set)
  2298. if (test_bit(AllReserved, &rdev2->flags) ||
  2299. (rdev->bdev == rdev2->bdev &&
  2300. rdev != rdev2 &&
  2301. overlaps(rdev->data_offset, rdev->sectors,
  2302. rdev2->data_offset,
  2303. rdev2->sectors))) {
  2304. overlap = 1;
  2305. break;
  2306. }
  2307. mddev_unlock(mddev);
  2308. if (overlap) {
  2309. mddev_put(mddev);
  2310. break;
  2311. }
  2312. }
  2313. mddev_lock(my_mddev);
  2314. if (overlap) {
  2315. /* Someone else could have slipped in a size
  2316. * change here, but doing so is just silly.
  2317. * We put oldsectors back because we *know* it is
  2318. * safe, and trust userspace not to race with
  2319. * itself
  2320. */
  2321. rdev->sectors = oldsectors;
  2322. return -EBUSY;
  2323. }
  2324. }
  2325. return len;
  2326. }
  2327. static struct rdev_sysfs_entry rdev_size =
  2328. __ATTR(size, S_IRUGO|S_IWUSR, rdev_size_show, rdev_size_store);
  2329. static ssize_t recovery_start_show(mdk_rdev_t *rdev, char *page)
  2330. {
  2331. unsigned long long recovery_start = rdev->recovery_offset;
  2332. if (test_bit(In_sync, &rdev->flags) ||
  2333. recovery_start == MaxSector)
  2334. return sprintf(page, "none\n");
  2335. return sprintf(page, "%llu\n", recovery_start);
  2336. }
  2337. static ssize_t recovery_start_store(mdk_rdev_t *rdev, const char *buf, size_t len)
  2338. {
  2339. unsigned long long recovery_start;
  2340. if (cmd_match(buf, "none"))
  2341. recovery_start = MaxSector;
  2342. else if (strict_strtoull(buf, 10, &recovery_start))
  2343. return -EINVAL;
  2344. if (rdev->mddev->pers &&
  2345. rdev->raid_disk >= 0)
  2346. return -EBUSY;
  2347. rdev->recovery_offset = recovery_start;
  2348. if (recovery_start == MaxSector)
  2349. set_bit(In_sync, &rdev->flags);
  2350. else
  2351. clear_bit(In_sync, &rdev->flags);
  2352. return len;
  2353. }
  2354. static struct rdev_sysfs_entry rdev_recovery_start =
  2355. __ATTR(recovery_start, S_IRUGO|S_IWUSR, recovery_start_show, recovery_start_store);
  2356. static struct attribute *rdev_default_attrs[] = {
  2357. &rdev_state.attr,
  2358. &rdev_errors.attr,
  2359. &rdev_slot.attr,
  2360. &rdev_offset.attr,
  2361. &rdev_size.attr,
  2362. &rdev_recovery_start.attr,
  2363. NULL,
  2364. };
  2365. static ssize_t
  2366. rdev_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
  2367. {
  2368. struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
  2369. mdk_rdev_t *rdev = container_of(kobj, mdk_rdev_t, kobj);
  2370. mddev_t *mddev = rdev->mddev;
  2371. ssize_t rv;
  2372. if (!entry->show)
  2373. return -EIO;
  2374. rv = mddev ? mddev_lock(mddev) : -EBUSY;
  2375. if (!rv) {
  2376. if (rdev->mddev == NULL)
  2377. rv = -EBUSY;
  2378. else
  2379. rv = entry->show(rdev, page);
  2380. mddev_unlock(mddev);
  2381. }
  2382. return rv;
  2383. }
  2384. static ssize_t
  2385. rdev_attr_store(struct kobject *kobj, struct attribute *attr,
  2386. const char *page, size_t length)
  2387. {
  2388. struct rdev_sysfs_entry *entry = container_of(attr, struct rdev_sysfs_entry, attr);
  2389. mdk_rdev_t *rdev = container_of(kobj, mdk_rdev_t, kobj);
  2390. ssize_t rv;
  2391. mddev_t *mddev = rdev->mddev;
  2392. if (!entry->store)
  2393. return -EIO;
  2394. if (!capable(CAP_SYS_ADMIN))
  2395. return -EACCES;
  2396. rv = mddev ? mddev_lock(mddev): -EBUSY;
  2397. if (!rv) {
  2398. if (rdev->mddev == NULL)
  2399. rv = -EBUSY;
  2400. else
  2401. rv = entry->store(rdev, page, length);
  2402. mddev_unlock(mddev);
  2403. }
  2404. return rv;
  2405. }
  2406. static void rdev_free(struct kobject *ko)
  2407. {
  2408. mdk_rdev_t *rdev = container_of(ko, mdk_rdev_t, kobj);
  2409. kfree(rdev);
  2410. }
  2411. static const struct sysfs_ops rdev_sysfs_ops = {
  2412. .show = rdev_attr_show,
  2413. .store = rdev_attr_store,
  2414. };
  2415. static struct kobj_type rdev_ktype = {
  2416. .release = rdev_free,
  2417. .sysfs_ops = &rdev_sysfs_ops,
  2418. .default_attrs = rdev_default_attrs,
  2419. };
  2420. void md_rdev_init(mdk_rdev_t *rdev)
  2421. {
  2422. rdev->desc_nr = -1;
  2423. rdev->saved_raid_disk = -1;
  2424. rdev->raid_disk = -1;
  2425. rdev->flags = 0;
  2426. rdev->data_offset = 0;
  2427. rdev->sb_events = 0;
  2428. rdev->last_read_error.tv_sec = 0;
  2429. rdev->last_read_error.tv_nsec = 0;
  2430. atomic_set(&rdev->nr_pending, 0);
  2431. atomic_set(&rdev->read_errors, 0);
  2432. atomic_set(&rdev->corrected_errors, 0);
  2433. INIT_LIST_HEAD(&rdev->same_set);
  2434. init_waitqueue_head(&rdev->blocked_wait);
  2435. }
  2436. EXPORT_SYMBOL_GPL(md_rdev_init);
  2437. /*
  2438. * Import a device. If 'super_format' >= 0, then sanity check the superblock
  2439. *
  2440. * mark the device faulty if:
  2441. *
  2442. * - the device is nonexistent (zero size)
  2443. * - the device has no valid superblock
  2444. *
  2445. * a faulty rdev _never_ has rdev->sb set.
  2446. */
  2447. static mdk_rdev_t *md_import_device(dev_t newdev, int super_format, int super_minor)
  2448. {
  2449. char b[BDEVNAME_SIZE];
  2450. int err;
  2451. mdk_rdev_t *rdev;
  2452. sector_t size;
  2453. rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
  2454. if (!rdev) {
  2455. printk(KERN_ERR "md: could not alloc mem for new device!\n");
  2456. return ERR_PTR(-ENOMEM);
  2457. }
  2458. md_rdev_init(rdev);
  2459. if ((err = alloc_disk_sb(rdev)))
  2460. goto abort_free;
  2461. err = lock_rdev(rdev, newdev, super_format == -2);
  2462. if (err)
  2463. goto abort_free;
  2464. kobject_init(&rdev->kobj, &rdev_ktype);
  2465. size = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
  2466. if (!size) {
  2467. printk(KERN_WARNING
  2468. "md: %s has zero or unknown size, marking faulty!\n",
  2469. bdevname(rdev->bdev,b));
  2470. err = -EINVAL;
  2471. goto abort_free;
  2472. }
  2473. if (super_format >= 0) {
  2474. err = super_types[super_format].
  2475. load_super(rdev, NULL, super_minor);
  2476. if (err == -EINVAL) {
  2477. printk(KERN_WARNING
  2478. "md: %s does not have a valid v%d.%d "
  2479. "superblock, not importing!\n",
  2480. bdevname(rdev->bdev,b),
  2481. super_format, super_minor);
  2482. goto abort_free;
  2483. }
  2484. if (err < 0) {
  2485. printk(KERN_WARNING
  2486. "md: could not read %s's sb, not importing!\n",
  2487. bdevname(rdev->bdev,b));
  2488. goto abort_free;
  2489. }
  2490. }
  2491. return rdev;
  2492. abort_free:
  2493. if (rdev->sb_page) {
  2494. if (rdev->bdev)
  2495. unlock_rdev(rdev);
  2496. free_disk_sb(rdev);
  2497. }
  2498. kfree(rdev);
  2499. return ERR_PTR(err);
  2500. }
  2501. /*
  2502. * Check a full RAID array for plausibility
  2503. */
  2504. static void analyze_sbs(mddev_t * mddev)
  2505. {
  2506. int i;
  2507. mdk_rdev_t *rdev, *freshest, *tmp;
  2508. char b[BDEVNAME_SIZE];
  2509. freshest = NULL;
  2510. rdev_for_each(rdev, tmp, mddev)
  2511. switch (super_types[mddev->major_version].
  2512. load_super(rdev, freshest, mddev->minor_version)) {
  2513. case 1:
  2514. freshest = rdev;
  2515. break;
  2516. case 0:
  2517. break;
  2518. default:
  2519. printk( KERN_ERR \
  2520. "md: fatal superblock inconsistency in %s"
  2521. " -- removing from array\n",
  2522. bdevname(rdev->bdev,b));
  2523. kick_rdev_from_array(rdev);
  2524. }
  2525. super_types[mddev->major_version].
  2526. validate_super(mddev, freshest);
  2527. i = 0;
  2528. rdev_for_each(rdev, tmp, mddev) {
  2529. if (mddev->max_disks &&
  2530. (rdev->desc_nr >= mddev->max_disks ||
  2531. i > mddev->max_disks)) {
  2532. printk(KERN_WARNING
  2533. "md: %s: %s: only %d devices permitted\n",
  2534. mdname(mddev), bdevname(rdev->bdev, b),
  2535. mddev->max_disks);
  2536. kick_rdev_from_array(rdev);
  2537. continue;
  2538. }
  2539. if (rdev != freshest)
  2540. if (super_types[mddev->major_version].
  2541. validate_super(mddev, rdev)) {
  2542. printk(KERN_WARNING "md: kicking non-fresh %s"
  2543. " from array!\n",
  2544. bdevname(rdev->bdev,b));
  2545. kick_rdev_from_array(rdev);
  2546. continue;
  2547. }
  2548. if (mddev->level == LEVEL_MULTIPATH) {
  2549. rdev->desc_nr = i++;
  2550. rdev->raid_disk = rdev->desc_nr;
  2551. set_bit(In_sync, &rdev->flags);
  2552. } else if (rdev->raid_disk >= (mddev->raid_disks - min(0, mddev->delta_disks))) {
  2553. rdev->raid_disk = -1;
  2554. clear_bit(In_sync, &rdev->flags);
  2555. }
  2556. }
  2557. }
  2558. /* Read a fixed-point number.
  2559. * Numbers in sysfs attributes should be in "standard" units where
  2560. * possible, so time should be in seconds.
  2561. * However we internally use a a much smaller unit such as
  2562. * milliseconds or jiffies.
  2563. * This function takes a decimal number with a possible fractional
  2564. * component, and produces an integer which is the result of
  2565. * multiplying that number by 10^'scale'.
  2566. * all without any floating-point arithmetic.
  2567. */
  2568. int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale)
  2569. {
  2570. unsigned long result = 0;
  2571. long decimals = -1;
  2572. while (isdigit(*cp) || (*cp == '.' && decimals < 0)) {
  2573. if (*cp == '.')
  2574. decimals = 0;
  2575. else if (decimals < scale) {
  2576. unsigned int value;
  2577. value = *cp - '0';
  2578. result = result * 10 + value;
  2579. if (decimals >= 0)
  2580. decimals++;
  2581. }
  2582. cp++;
  2583. }
  2584. if (*cp == '\n')
  2585. cp++;
  2586. if (*cp)
  2587. return -EINVAL;
  2588. if (decimals < 0)
  2589. decimals = 0;
  2590. while (decimals < scale) {
  2591. result *= 10;
  2592. decimals ++;
  2593. }
  2594. *res = result;
  2595. return 0;
  2596. }
  2597. static void md_safemode_timeout(unsigned long data);
  2598. static ssize_t
  2599. safe_delay_show(mddev_t *mddev, char *page)
  2600. {
  2601. int msec = (mddev->safemode_delay*1000)/HZ;
  2602. return sprintf(page, "%d.%03d\n", msec/1000, msec%1000);
  2603. }
  2604. static ssize_t
  2605. safe_delay_store(mddev_t *mddev, const char *cbuf, size_t len)
  2606. {
  2607. unsigned long msec;
  2608. if (strict_strtoul_scaled(cbuf, &msec, 3) < 0)
  2609. return -EINVAL;
  2610. if (msec == 0)
  2611. mddev->safemode_delay = 0;
  2612. else {
  2613. unsigned long old_delay = mddev->safemode_delay;
  2614. mddev->safemode_delay = (msec*HZ)/1000;
  2615. if (mddev->safemode_delay == 0)
  2616. mddev->safemode_delay = 1;
  2617. if (mddev->safemode_delay < old_delay)
  2618. md_safemode_timeout((unsigned long)mddev);
  2619. }
  2620. return len;
  2621. }
  2622. static struct md_sysfs_entry md_safe_delay =
  2623. __ATTR(safe_mode_delay, S_IRUGO|S_IWUSR,safe_delay_show, safe_delay_store);
  2624. static ssize_t
  2625. level_show(mddev_t *mddev, char *page)
  2626. {
  2627. struct mdk_personality *p = mddev->pers;
  2628. if (p)
  2629. return sprintf(page, "%s\n", p->name);
  2630. else if (mddev->clevel[0])
  2631. return sprintf(page, "%s\n", mddev->clevel);
  2632. else if (mddev->level != LEVEL_NONE)
  2633. return sprintf(page, "%d\n", mddev->level);
  2634. else
  2635. return 0;
  2636. }
  2637. static ssize_t
  2638. level_store(mddev_t *mddev, const char *buf, size_t len)
  2639. {
  2640. char clevel[16];
  2641. ssize_t rv = len;
  2642. struct mdk_personality *pers;
  2643. long level;
  2644. void *priv;
  2645. mdk_rdev_t *rdev;
  2646. if (mddev->pers == NULL) {
  2647. if (len == 0)
  2648. return 0;
  2649. if (len >= sizeof(mddev->clevel))
  2650. return -ENOSPC;
  2651. strncpy(mddev->clevel, buf, len);
  2652. if (mddev->clevel[len-1] == '\n')
  2653. len--;
  2654. mddev->clevel[len] = 0;
  2655. mddev->level = LEVEL_NONE;
  2656. return rv;
  2657. }
  2658. /* request to change the personality. Need to ensure:
  2659. * - array is not engaged in resync/recovery/reshape
  2660. * - old personality can be suspended
  2661. * - new personality will access other array.
  2662. */
  2663. if (mddev->sync_thread ||
  2664. mddev->reshape_position != MaxSector ||
  2665. mddev->sysfs_active)
  2666. return -EBUSY;
  2667. if (!mddev->pers->quiesce) {
  2668. printk(KERN_WARNING "md: %s: %s does not support online personality change\n",
  2669. mdname(mddev), mddev->pers->name);
  2670. return -EINVAL;
  2671. }
  2672. /* Now find the new personality */
  2673. if (len == 0 || len >= sizeof(clevel))
  2674. return -EINVAL;
  2675. strncpy(clevel, buf, len);
  2676. if (clevel[len-1] == '\n')
  2677. len--;
  2678. clevel[len] = 0;
  2679. if (strict_strtol(clevel, 10, &level))
  2680. level = LEVEL_NONE;
  2681. if (request_module("md-%s", clevel) != 0)
  2682. request_module("md-level-%s", clevel);
  2683. spin_lock(&pers_lock);
  2684. pers = find_pers(level, clevel);
  2685. if (!pers || !try_module_get(pers->owner)) {
  2686. spin_unlock(&pers_lock);
  2687. printk(KERN_WARNING "md: personality %s not loaded\n", clevel);
  2688. return -EINVAL;
  2689. }
  2690. spin_unlock(&pers_lock);
  2691. if (pers == mddev->pers) {
  2692. /* Nothing to do! */
  2693. module_put(pers->owner);
  2694. return rv;
  2695. }
  2696. if (!pers->takeover) {
  2697. module_put(pers->owner);
  2698. printk(KERN_WARNING "md: %s: %s does not support personality takeover\n",
  2699. mdname(mddev), clevel);
  2700. return -EINVAL;
  2701. }
  2702. list_for_each_entry(rdev, &mddev->disks, same_set)
  2703. rdev->new_raid_disk = rdev->raid_disk;
  2704. /* ->takeover must set new_* and/or delta_disks
  2705. * if it succeeds, and may set them when it fails.
  2706. */
  2707. priv = pers->takeover(mddev);
  2708. if (IS_ERR(priv)) {
  2709. mddev->new_level = mddev->level;
  2710. mddev->new_layout = mddev->layout;
  2711. mddev->new_chunk_sectors = mddev->chunk_sectors;
  2712. mddev->raid_disks -= mddev->delta_disks;
  2713. mddev->delta_disks = 0;
  2714. module_put(pers->owner);
  2715. printk(KERN_WARNING "md: %s: %s would not accept array\n",
  2716. mdname(mddev), clevel);
  2717. return PTR_ERR(priv);
  2718. }
  2719. /* Looks like we have a winner */
  2720. mddev_suspend(mddev);
  2721. mddev->pers->stop(mddev);
  2722. if (mddev->pers->sync_request == NULL &&
  2723. pers->sync_request != NULL) {
  2724. /* need to add the md_redundancy_group */
  2725. if (sysfs_create_group(&mddev->kobj, &md_redundancy_group))
  2726. printk(KERN_WARNING
  2727. "md: cannot register extra attributes for %s\n",
  2728. mdname(mddev));
  2729. mddev->sysfs_action = sysfs_get_dirent(mddev->kobj.sd, NULL, "sync_action");
  2730. }
  2731. if (mddev->pers->sync_request != NULL &&
  2732. pers->sync_request == NULL) {
  2733. /* need to remove the md_redundancy_group */
  2734. if (mddev->to_remove == NULL)
  2735. mddev->to_remove = &md_redundancy_group;
  2736. }
  2737. if (mddev->pers->sync_request == NULL &&
  2738. mddev->external) {
  2739. /* We are converting from a no-redundancy array
  2740. * to a redundancy array and metadata is managed
  2741. * externally so we need to be sure that writes
  2742. * won't block due to a need to transition
  2743. * clean->dirty
  2744. * until external management is started.
  2745. */
  2746. mddev->in_sync = 0;
  2747. mddev->safemode_delay = 0;
  2748. mddev->safemode = 0;
  2749. }
  2750. list_for_each_entry(rdev, &mddev->disks, same_set) {
  2751. char nm[20];
  2752. if (rdev->raid_disk < 0)
  2753. continue;
  2754. if (rdev->new_raid_disk > mddev->raid_disks)
  2755. rdev->new_raid_disk = -1;
  2756. if (rdev->new_raid_disk == rdev->raid_disk)
  2757. continue;
  2758. sprintf(nm, "rd%d", rdev->raid_disk);
  2759. sysfs_remove_link(&mddev->kobj, nm);
  2760. }
  2761. list_for_each_entry(rdev, &mddev->disks, same_set) {
  2762. if (rdev->raid_disk < 0)
  2763. continue;
  2764. if (rdev->new_raid_disk == rdev->raid_disk)
  2765. continue;
  2766. rdev->raid_disk = rdev->new_raid_disk;
  2767. if (rdev->raid_disk < 0)
  2768. clear_bit(In_sync, &rdev->flags);
  2769. else {
  2770. char nm[20];
  2771. sprintf(nm, "rd%d", rdev->raid_disk);
  2772. if(sysfs_create_link(&mddev->kobj, &rdev->kobj, nm))
  2773. printk("md: cannot register %s for %s after level change\n",
  2774. nm, mdname(mddev));
  2775. }
  2776. }
  2777. module_put(mddev->pers->owner);
  2778. mddev->pers = pers;
  2779. mddev->private = priv;
  2780. strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
  2781. mddev->level = mddev->new_level;
  2782. mddev->layout = mddev->new_layout;
  2783. mddev->chunk_sectors = mddev->new_chunk_sectors;
  2784. mddev->delta_disks = 0;
  2785. if (mddev->pers->sync_request == NULL) {
  2786. /* this is now an array without redundancy, so
  2787. * it must always be in_sync
  2788. */
  2789. mddev->in_sync = 1;
  2790. del_timer_sync(&mddev->safemode_timer);
  2791. }
  2792. pers->run(mddev);
  2793. mddev_resume(mddev);
  2794. set_bit(MD_CHANGE_DEVS, &mddev->flags);
  2795. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  2796. md_wakeup_thread(mddev->thread);
  2797. sysfs_notify(&mddev->kobj, NULL, "level");
  2798. md_new_event(mddev);
  2799. return rv;
  2800. }
  2801. static struct md_sysfs_entry md_level =
  2802. __ATTR(level, S_IRUGO|S_IWUSR, level_show, level_store);
  2803. static ssize_t
  2804. layout_show(mddev_t *mddev, char *page)
  2805. {
  2806. /* just a number, not meaningful for all levels */
  2807. if (mddev->reshape_position != MaxSector &&
  2808. mddev->layout != mddev->new_layout)
  2809. return sprintf(page, "%d (%d)\n",
  2810. mddev->new_layout, mddev->layout);
  2811. return sprintf(page, "%d\n", mddev->layout);
  2812. }
  2813. static ssize_t
  2814. layout_store(mddev_t *mddev, const char *buf, size_t len)
  2815. {
  2816. char *e;
  2817. unsigned long n = simple_strtoul(buf, &e, 10);
  2818. if (!*buf || (*e && *e != '\n'))
  2819. return -EINVAL;
  2820. if (mddev->pers) {
  2821. int err;
  2822. if (mddev->pers->check_reshape == NULL)
  2823. return -EBUSY;
  2824. mddev->new_layout = n;
  2825. err = mddev->pers->check_reshape(mddev);
  2826. if (err) {
  2827. mddev->new_layout = mddev->layout;
  2828. return err;
  2829. }
  2830. } else {
  2831. mddev->new_layout = n;
  2832. if (mddev->reshape_position == MaxSector)
  2833. mddev->layout = n;
  2834. }
  2835. return len;
  2836. }
  2837. static struct md_sysfs_entry md_layout =
  2838. __ATTR(layout, S_IRUGO|S_IWUSR, layout_show, layout_store);
  2839. static ssize_t
  2840. raid_disks_show(mddev_t *mddev, char *page)
  2841. {
  2842. if (mddev->raid_disks == 0)
  2843. return 0;
  2844. if (mddev->reshape_position != MaxSector &&
  2845. mddev->delta_disks != 0)
  2846. return sprintf(page, "%d (%d)\n", mddev->raid_disks,
  2847. mddev->raid_disks - mddev->delta_disks);
  2848. return sprintf(page, "%d\n", mddev->raid_disks);
  2849. }
  2850. static int update_raid_disks(mddev_t *mddev, int raid_disks);
  2851. static ssize_t
  2852. raid_disks_store(mddev_t *mddev, const char *buf, size_t len)
  2853. {
  2854. char *e;
  2855. int rv = 0;
  2856. unsigned long n = simple_strtoul(buf, &e, 10);
  2857. if (!*buf || (*e && *e != '\n'))
  2858. return -EINVAL;
  2859. if (mddev->pers)
  2860. rv = update_raid_disks(mddev, n);
  2861. else if (mddev->reshape_position != MaxSector) {
  2862. int olddisks = mddev->raid_disks - mddev->delta_disks;
  2863. mddev->delta_disks = n - olddisks;
  2864. mddev->raid_disks = n;
  2865. } else
  2866. mddev->raid_disks = n;
  2867. return rv ? rv : len;
  2868. }
  2869. static struct md_sysfs_entry md_raid_disks =
  2870. __ATTR(raid_disks, S_IRUGO|S_IWUSR, raid_disks_show, raid_disks_store);
  2871. static ssize_t
  2872. chunk_size_show(mddev_t *mddev, char *page)
  2873. {
  2874. if (mddev->reshape_position != MaxSector &&
  2875. mddev->chunk_sectors != mddev->new_chunk_sectors)
  2876. return sprintf(page, "%d (%d)\n",
  2877. mddev->new_chunk_sectors << 9,
  2878. mddev->chunk_sectors << 9);
  2879. return sprintf(page, "%d\n", mddev->chunk_sectors << 9);
  2880. }
  2881. static ssize_t
  2882. chunk_size_store(mddev_t *mddev, const char *buf, size_t len)
  2883. {
  2884. char *e;
  2885. unsigned long n = simple_strtoul(buf, &e, 10);
  2886. if (!*buf || (*e && *e != '\n'))
  2887. return -EINVAL;
  2888. if (mddev->pers) {
  2889. int err;
  2890. if (mddev->pers->check_reshape == NULL)
  2891. return -EBUSY;
  2892. mddev->new_chunk_sectors = n >> 9;
  2893. err = mddev->pers->check_reshape(mddev);
  2894. if (err) {
  2895. mddev->new_chunk_sectors = mddev->chunk_sectors;
  2896. return err;
  2897. }
  2898. } else {
  2899. mddev->new_chunk_sectors = n >> 9;
  2900. if (mddev->reshape_position == MaxSector)
  2901. mddev->chunk_sectors = n >> 9;
  2902. }
  2903. return len;
  2904. }
  2905. static struct md_sysfs_entry md_chunk_size =
  2906. __ATTR(chunk_size, S_IRUGO|S_IWUSR, chunk_size_show, chunk_size_store);
  2907. static ssize_t
  2908. resync_start_show(mddev_t *mddev, char *page)
  2909. {
  2910. if (mddev->recovery_cp == MaxSector)
  2911. return sprintf(page, "none\n");
  2912. return sprintf(page, "%llu\n", (unsigned long long)mddev->recovery_cp);
  2913. }
  2914. static ssize_t
  2915. resync_start_store(mddev_t *mddev, const char *buf, size_t len)
  2916. {
  2917. char *e;
  2918. unsigned long long n = simple_strtoull(buf, &e, 10);
  2919. if (mddev->pers)
  2920. return -EBUSY;
  2921. if (cmd_match(buf, "none"))
  2922. n = MaxSector;
  2923. else if (!*buf || (*e && *e != '\n'))
  2924. return -EINVAL;
  2925. mddev->recovery_cp = n;
  2926. return len;
  2927. }
  2928. static struct md_sysfs_entry md_resync_start =
  2929. __ATTR(resync_start, S_IRUGO|S_IWUSR, resync_start_show, resync_start_store);
  2930. /*
  2931. * The array state can be:
  2932. *
  2933. * clear
  2934. * No devices, no size, no level
  2935. * Equivalent to STOP_ARRAY ioctl
  2936. * inactive
  2937. * May have some settings, but array is not active
  2938. * all IO results in error
  2939. * When written, doesn't tear down array, but just stops it
  2940. * suspended (not supported yet)
  2941. * All IO requests will block. The array can be reconfigured.
  2942. * Writing this, if accepted, will block until array is quiescent
  2943. * readonly
  2944. * no resync can happen. no superblocks get written.
  2945. * write requests fail
  2946. * read-auto
  2947. * like readonly, but behaves like 'clean' on a write request.
  2948. *
  2949. * clean - no pending writes, but otherwise active.
  2950. * When written to inactive array, starts without resync
  2951. * If a write request arrives then
  2952. * if metadata is known, mark 'dirty' and switch to 'active'.
  2953. * if not known, block and switch to write-pending
  2954. * If written to an active array that has pending writes, then fails.
  2955. * active
  2956. * fully active: IO and resync can be happening.
  2957. * When written to inactive array, starts with resync
  2958. *
  2959. * write-pending
  2960. * clean, but writes are blocked waiting for 'active' to be written.
  2961. *
  2962. * active-idle
  2963. * like active, but no writes have been seen for a while (100msec).
  2964. *
  2965. */
  2966. enum array_state { clear, inactive, suspended, readonly, read_auto, clean, active,
  2967. write_pending, active_idle, bad_word};
  2968. static char *array_states[] = {
  2969. "clear", "inactive", "suspended", "readonly", "read-auto", "clean", "active",
  2970. "write-pending", "active-idle", NULL };
  2971. static int match_word(const char *word, char **list)
  2972. {
  2973. int n;
  2974. for (n=0; list[n]; n++)
  2975. if (cmd_match(word, list[n]))
  2976. break;
  2977. return n;
  2978. }
  2979. static ssize_t
  2980. array_state_show(mddev_t *mddev, char *page)
  2981. {
  2982. enum array_state st = inactive;
  2983. if (mddev->pers)
  2984. switch(mddev->ro) {
  2985. case 1:
  2986. st = readonly;
  2987. break;
  2988. case 2:
  2989. st = read_auto;
  2990. break;
  2991. case 0:
  2992. if (mddev->in_sync)
  2993. st = clean;
  2994. else if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
  2995. st = write_pending;
  2996. else if (mddev->safemode)
  2997. st = active_idle;
  2998. else
  2999. st = active;
  3000. }
  3001. else {
  3002. if (list_empty(&mddev->disks) &&
  3003. mddev->raid_disks == 0 &&
  3004. mddev->dev_sectors == 0)
  3005. st = clear;
  3006. else
  3007. st = inactive;
  3008. }
  3009. return sprintf(page, "%s\n", array_states[st]);
  3010. }
  3011. static int do_md_stop(mddev_t * mddev, int ro, int is_open);
  3012. static int md_set_readonly(mddev_t * mddev, int is_open);
  3013. static int do_md_run(mddev_t * mddev);
  3014. static int restart_array(mddev_t *mddev);
  3015. static ssize_t
  3016. array_state_store(mddev_t *mddev, const char *buf, size_t len)
  3017. {
  3018. int err = -EINVAL;
  3019. enum array_state st = match_word(buf, array_states);
  3020. switch(st) {
  3021. case bad_word:
  3022. break;
  3023. case clear:
  3024. /* stopping an active array */
  3025. if (atomic_read(&mddev->openers) > 0)
  3026. return -EBUSY;
  3027. err = do_md_stop(mddev, 0, 0);
  3028. break;
  3029. case inactive:
  3030. /* stopping an active array */
  3031. if (mddev->pers) {
  3032. if (atomic_read(&mddev->openers) > 0)
  3033. return -EBUSY;
  3034. err = do_md_stop(mddev, 2, 0);
  3035. } else
  3036. err = 0; /* already inactive */
  3037. break;
  3038. case suspended:
  3039. break; /* not supported yet */
  3040. case readonly:
  3041. if (mddev->pers)
  3042. err = md_set_readonly(mddev, 0);
  3043. else {
  3044. mddev->ro = 1;
  3045. set_disk_ro(mddev->gendisk, 1);
  3046. err = do_md_run(mddev);
  3047. }
  3048. break;
  3049. case read_auto:
  3050. if (mddev->pers) {
  3051. if (mddev->ro == 0)
  3052. err = md_set_readonly(mddev, 0);
  3053. else if (mddev->ro == 1)
  3054. err = restart_array(mddev);
  3055. if (err == 0) {
  3056. mddev->ro = 2;
  3057. set_disk_ro(mddev->gendisk, 0);
  3058. }
  3059. } else {
  3060. mddev->ro = 2;
  3061. err = do_md_run(mddev);
  3062. }
  3063. break;
  3064. case clean:
  3065. if (mddev->pers) {
  3066. restart_array(mddev);
  3067. spin_lock_irq(&mddev->write_lock);
  3068. if (atomic_read(&mddev->writes_pending) == 0) {
  3069. if (mddev->in_sync == 0) {
  3070. mddev->in_sync = 1;
  3071. if (mddev->safemode == 1)
  3072. mddev->safemode = 0;
  3073. set_bit(MD_CHANGE_CLEAN, &mddev->flags);
  3074. }
  3075. err = 0;
  3076. } else
  3077. err = -EBUSY;
  3078. spin_unlock_irq(&mddev->write_lock);
  3079. } else
  3080. err = -EINVAL;
  3081. break;
  3082. case active:
  3083. if (mddev->pers) {
  3084. restart_array(mddev);
  3085. clear_bit(MD_CHANGE_PENDING, &mddev->flags);
  3086. wake_up(&mddev->sb_wait);
  3087. err = 0;
  3088. } else {
  3089. mddev->ro = 0;
  3090. set_disk_ro(mddev->gendisk, 0);
  3091. err = do_md_run(mddev);
  3092. }
  3093. break;
  3094. case write_pending:
  3095. case active_idle:
  3096. /* these cannot be set */
  3097. break;
  3098. }
  3099. if (err)
  3100. return err;
  3101. else {
  3102. sysfs_notify_dirent_safe(mddev->sysfs_state);
  3103. return len;
  3104. }
  3105. }
  3106. static struct md_sysfs_entry md_array_state =
  3107. __ATTR(array_state, S_IRUGO|S_IWUSR, array_state_show, array_state_store);
  3108. static ssize_t
  3109. max_corrected_read_errors_show(mddev_t *mddev, char *page) {
  3110. return sprintf(page, "%d\n",
  3111. atomic_read(&mddev->max_corr_read_errors));
  3112. }
  3113. static ssize_t
  3114. max_corrected_read_errors_store(mddev_t *mddev, const char *buf, size_t len)
  3115. {
  3116. char *e;
  3117. unsigned long n = simple_strtoul(buf, &e, 10);
  3118. if (*buf && (*e == 0 || *e == '\n')) {
  3119. atomic_set(&mddev->max_corr_read_errors, n);
  3120. return len;
  3121. }
  3122. return -EINVAL;
  3123. }
  3124. static struct md_sysfs_entry max_corr_read_errors =
  3125. __ATTR(max_read_errors, S_IRUGO|S_IWUSR, max_corrected_read_errors_show,
  3126. max_corrected_read_errors_store);
  3127. static ssize_t
  3128. null_show(mddev_t *mddev, char *page)
  3129. {
  3130. return -EINVAL;
  3131. }
  3132. static ssize_t
  3133. new_dev_store(mddev_t *mddev, const char *buf, size_t len)
  3134. {
  3135. /* buf must be %d:%d\n? giving major and minor numbers */
  3136. /* The new device is added to the array.
  3137. * If the array has a persistent superblock, we read the
  3138. * superblock to initialise info and check validity.
  3139. * Otherwise, only checking done is that in bind_rdev_to_array,
  3140. * which mainly checks size.
  3141. */
  3142. char *e;
  3143. int major = simple_strtoul(buf, &e, 10);
  3144. int minor;
  3145. dev_t dev;
  3146. mdk_rdev_t *rdev;
  3147. int err;
  3148. if (!*buf || *e != ':' || !e[1] || e[1] == '\n')
  3149. return -EINVAL;
  3150. minor = simple_strtoul(e+1, &e, 10);
  3151. if (*e && *e != '\n')
  3152. return -EINVAL;
  3153. dev = MKDEV(major, minor);
  3154. if (major != MAJOR(dev) ||
  3155. minor != MINOR(dev))
  3156. return -EOVERFLOW;
  3157. if (mddev->persistent) {
  3158. rdev = md_import_device(dev, mddev->major_version,
  3159. mddev->minor_version);
  3160. if (!IS_ERR(rdev) && !list_empty(&mddev->disks)) {
  3161. mdk_rdev_t *rdev0 = list_entry(mddev->disks.next,
  3162. mdk_rdev_t, same_set);
  3163. err = super_types[mddev->major_version]
  3164. .load_super(rdev, rdev0, mddev->minor_version);
  3165. if (err < 0)
  3166. goto out;
  3167. }
  3168. } else if (mddev->external)
  3169. rdev = md_import_device(dev, -2, -1);
  3170. else
  3171. rdev = md_import_device(dev, -1, -1);
  3172. if (IS_ERR(rdev))
  3173. return PTR_ERR(rdev);
  3174. err = bind_rdev_to_array(rdev, mddev);
  3175. out:
  3176. if (err)
  3177. export_rdev(rdev);
  3178. return err ? err : len;
  3179. }
  3180. static struct md_sysfs_entry md_new_device =
  3181. __ATTR(new_dev, S_IWUSR, null_show, new_dev_store);
  3182. static ssize_t
  3183. bitmap_store(mddev_t *mddev, const char *buf, size_t len)
  3184. {
  3185. char *end;
  3186. unsigned long chunk, end_chunk;
  3187. if (!mddev->bitmap)
  3188. goto out;
  3189. /* buf should be <chunk> <chunk> ... or <chunk>-<chunk> ... (range) */
  3190. while (*buf) {
  3191. chunk = end_chunk = simple_strtoul(buf, &end, 0);
  3192. if (buf == end) break;
  3193. if (*end == '-') { /* range */
  3194. buf = end + 1;
  3195. end_chunk = simple_strtoul(buf, &end, 0);
  3196. if (buf == end) break;
  3197. }
  3198. if (*end && !isspace(*end)) break;
  3199. bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk);
  3200. buf = skip_spaces(end);
  3201. }
  3202. bitmap_unplug(mddev->bitmap); /* flush the bits to disk */
  3203. out:
  3204. return len;
  3205. }
  3206. static struct md_sysfs_entry md_bitmap =
  3207. __ATTR(bitmap_set_bits, S_IWUSR, null_show, bitmap_store);
  3208. static ssize_t
  3209. size_show(mddev_t *mddev, char *page)
  3210. {
  3211. return sprintf(page, "%llu\n",
  3212. (unsigned long long)mddev->dev_sectors / 2);
  3213. }
  3214. static int update_size(mddev_t *mddev, sector_t num_sectors);
  3215. static ssize_t
  3216. size_store(mddev_t *mddev, const char *buf, size_t len)
  3217. {
  3218. /* If array is inactive, we can reduce the component size, but
  3219. * not increase it (except from 0).
  3220. * If array is active, we can try an on-line resize
  3221. */
  3222. sector_t sectors;
  3223. int err = strict_blocks_to_sectors(buf, &sectors);
  3224. if (err < 0)
  3225. return err;
  3226. if (mddev->pers) {
  3227. err = update_size(mddev, sectors);
  3228. md_update_sb(mddev, 1);
  3229. } else {
  3230. if (mddev->dev_sectors == 0 ||
  3231. mddev->dev_sectors > sectors)
  3232. mddev->dev_sectors = sectors;
  3233. else
  3234. err = -ENOSPC;
  3235. }
  3236. return err ? err : len;
  3237. }
  3238. static struct md_sysfs_entry md_size =
  3239. __ATTR(component_size, S_IRUGO|S_IWUSR, size_show, size_store);
  3240. /* Metdata version.
  3241. * This is one of
  3242. * 'none' for arrays with no metadata (good luck...)
  3243. * 'external' for arrays with externally managed metadata,
  3244. * or N.M for internally known formats
  3245. */
  3246. static ssize_t
  3247. metadata_show(mddev_t *mddev, char *page)
  3248. {
  3249. if (mddev->persistent)
  3250. return sprintf(page, "%d.%d\n",
  3251. mddev->major_version, mddev->minor_version);
  3252. else if (mddev->external)
  3253. return sprintf(page, "external:%s\n", mddev->metadata_type);
  3254. else
  3255. return sprintf(page, "none\n");
  3256. }
  3257. static ssize_t
  3258. metadata_store(mddev_t *mddev, const char *buf, size_t len)
  3259. {
  3260. int major, minor;
  3261. char *e;
  3262. /* Changing the details of 'external' metadata is
  3263. * always permitted. Otherwise there must be
  3264. * no devices attached to the array.
  3265. */
  3266. if (mddev->external && strncmp(buf, "external:", 9) == 0)
  3267. ;
  3268. else if (!list_empty(&mddev->disks))
  3269. return -EBUSY;
  3270. if (cmd_match(buf, "none")) {
  3271. mddev->persistent = 0;
  3272. mddev->external = 0;
  3273. mddev->major_version = 0;
  3274. mddev->minor_version = 90;
  3275. return len;
  3276. }
  3277. if (strncmp(buf, "external:", 9) == 0) {
  3278. size_t namelen = len-9;
  3279. if (namelen >= sizeof(mddev->metadata_type))
  3280. namelen = sizeof(mddev->metadata_type)-1;
  3281. strncpy(mddev->metadata_type, buf+9, namelen);
  3282. mddev->metadata_type[namelen] = 0;
  3283. if (namelen && mddev->metadata_type[namelen-1] == '\n')
  3284. mddev->metadata_type[--namelen] = 0;
  3285. mddev->persistent = 0;
  3286. mddev->external = 1;
  3287. mddev->major_version = 0;
  3288. mddev->minor_version = 90;
  3289. return len;
  3290. }
  3291. major = simple_strtoul(buf, &e, 10);
  3292. if (e==buf || *e != '.')
  3293. return -EINVAL;
  3294. buf = e+1;
  3295. minor = simple_strtoul(buf, &e, 10);
  3296. if (e==buf || (*e && *e != '\n') )
  3297. return -EINVAL;
  3298. if (major >= ARRAY_SIZE(super_types) || super_types[major].name == NULL)
  3299. return -ENOENT;
  3300. mddev->major_version = major;
  3301. mddev->minor_version = minor;
  3302. mddev->persistent = 1;
  3303. mddev->external = 0;
  3304. return len;
  3305. }
  3306. static struct md_sysfs_entry md_metadata =
  3307. __ATTR(metadata_version, S_IRUGO|S_IWUSR, metadata_show, metadata_store);
  3308. static ssize_t
  3309. action_show(mddev_t *mddev, char *page)
  3310. {
  3311. char *type = "idle";
  3312. if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
  3313. type = "frozen";
  3314. else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
  3315. (!mddev->ro && test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))) {
  3316. if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
  3317. type = "reshape";
  3318. else if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
  3319. if (!test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
  3320. type = "resync";
  3321. else if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
  3322. type = "check";
  3323. else
  3324. type = "repair";
  3325. } else if (test_bit(MD_RECOVERY_RECOVER, &mddev->recovery))
  3326. type = "recover";
  3327. }
  3328. return sprintf(page, "%s\n", type);
  3329. }
  3330. static ssize_t
  3331. action_store(mddev_t *mddev, const char *page, size_t len)
  3332. {
  3333. if (!mddev->pers || !mddev->pers->sync_request)
  3334. return -EINVAL;
  3335. if (cmd_match(page, "frozen"))
  3336. set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
  3337. else
  3338. clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
  3339. if (cmd_match(page, "idle") || cmd_match(page, "frozen")) {
  3340. if (mddev->sync_thread) {
  3341. set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  3342. md_unregister_thread(mddev->sync_thread);
  3343. mddev->sync_thread = NULL;
  3344. mddev->recovery = 0;
  3345. }
  3346. } else if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) ||
  3347. test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
  3348. return -EBUSY;
  3349. else if (cmd_match(page, "resync"))
  3350. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  3351. else if (cmd_match(page, "recover")) {
  3352. set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
  3353. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  3354. } else if (cmd_match(page, "reshape")) {
  3355. int err;
  3356. if (mddev->pers->start_reshape == NULL)
  3357. return -EINVAL;
  3358. err = mddev->pers->start_reshape(mddev);
  3359. if (err)
  3360. return err;
  3361. sysfs_notify(&mddev->kobj, NULL, "degraded");
  3362. } else {
  3363. if (cmd_match(page, "check"))
  3364. set_bit(MD_RECOVERY_CHECK, &mddev->recovery);
  3365. else if (!cmd_match(page, "repair"))
  3366. return -EINVAL;
  3367. set_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
  3368. set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
  3369. }
  3370. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  3371. md_wakeup_thread(mddev->thread);
  3372. sysfs_notify_dirent_safe(mddev->sysfs_action);
  3373. return len;
  3374. }
  3375. static ssize_t
  3376. mismatch_cnt_show(mddev_t *mddev, char *page)
  3377. {
  3378. return sprintf(page, "%llu\n",
  3379. (unsigned long long) mddev->resync_mismatches);
  3380. }
  3381. static struct md_sysfs_entry md_scan_mode =
  3382. __ATTR(sync_action, S_IRUGO|S_IWUSR, action_show, action_store);
  3383. static struct md_sysfs_entry md_mismatches = __ATTR_RO(mismatch_cnt);
  3384. static ssize_t
  3385. sync_min_show(mddev_t *mddev, char *page)
  3386. {
  3387. return sprintf(page, "%d (%s)\n", speed_min(mddev),
  3388. mddev->sync_speed_min ? "local": "system");
  3389. }
  3390. static ssize_t
  3391. sync_min_store(mddev_t *mddev, const char *buf, size_t len)
  3392. {
  3393. int min;
  3394. char *e;
  3395. if (strncmp(buf, "system", 6)==0) {
  3396. mddev->sync_speed_min = 0;
  3397. return len;
  3398. }
  3399. min = simple_strtoul(buf, &e, 10);
  3400. if (buf == e || (*e && *e != '\n') || min <= 0)
  3401. return -EINVAL;
  3402. mddev->sync_speed_min = min;
  3403. return len;
  3404. }
  3405. static struct md_sysfs_entry md_sync_min =
  3406. __ATTR(sync_speed_min, S_IRUGO|S_IWUSR, sync_min_show, sync_min_store);
  3407. static ssize_t
  3408. sync_max_show(mddev_t *mddev, char *page)
  3409. {
  3410. return sprintf(page, "%d (%s)\n", speed_max(mddev),
  3411. mddev->sync_speed_max ? "local": "system");
  3412. }
  3413. static ssize_t
  3414. sync_max_store(mddev_t *mddev, const char *buf, size_t len)
  3415. {
  3416. int max;
  3417. char *e;
  3418. if (strncmp(buf, "system", 6)==0) {
  3419. mddev->sync_speed_max = 0;
  3420. return len;
  3421. }
  3422. max = simple_strtoul(buf, &e, 10);
  3423. if (buf == e || (*e && *e != '\n') || max <= 0)
  3424. return -EINVAL;
  3425. mddev->sync_speed_max = max;
  3426. return len;
  3427. }
  3428. static struct md_sysfs_entry md_sync_max =
  3429. __ATTR(sync_speed_max, S_IRUGO|S_IWUSR, sync_max_show, sync_max_store);
  3430. static ssize_t
  3431. degraded_show(mddev_t *mddev, char *page)
  3432. {
  3433. return sprintf(page, "%d\n", mddev->degraded);
  3434. }
  3435. static struct md_sysfs_entry md_degraded = __ATTR_RO(degraded);
  3436. static ssize_t
  3437. sync_force_parallel_show(mddev_t *mddev, char *page)
  3438. {
  3439. return sprintf(page, "%d\n", mddev->parallel_resync);
  3440. }
  3441. static ssize_t
  3442. sync_force_parallel_store(mddev_t *mddev, const char *buf, size_t len)
  3443. {
  3444. long n;
  3445. if (strict_strtol(buf, 10, &n))
  3446. return -EINVAL;
  3447. if (n != 0 && n != 1)
  3448. return -EINVAL;
  3449. mddev->parallel_resync = n;
  3450. if (mddev->sync_thread)
  3451. wake_up(&resync_wait);
  3452. return len;
  3453. }
  3454. /* force parallel resync, even with shared block devices */
  3455. static struct md_sysfs_entry md_sync_force_parallel =
  3456. __ATTR(sync_force_parallel, S_IRUGO|S_IWUSR,
  3457. sync_force_parallel_show, sync_force_parallel_store);
  3458. static ssize_t
  3459. sync_speed_show(mddev_t *mddev, char *page)
  3460. {
  3461. unsigned long resync, dt, db;
  3462. if (mddev->curr_resync == 0)
  3463. return sprintf(page, "none\n");
  3464. resync = mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active);
  3465. dt = (jiffies - mddev->resync_mark) / HZ;
  3466. if (!dt) dt++;
  3467. db = resync - mddev->resync_mark_cnt;
  3468. return sprintf(page, "%lu\n", db/dt/2); /* K/sec */
  3469. }
  3470. static struct md_sysfs_entry md_sync_speed = __ATTR_RO(sync_speed);
  3471. static ssize_t
  3472. sync_completed_show(mddev_t *mddev, char *page)
  3473. {
  3474. unsigned long max_sectors, resync;
  3475. if (!test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
  3476. return sprintf(page, "none\n");
  3477. if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
  3478. max_sectors = mddev->resync_max_sectors;
  3479. else
  3480. max_sectors = mddev->dev_sectors;
  3481. resync = mddev->curr_resync_completed;
  3482. return sprintf(page, "%lu / %lu\n", resync, max_sectors);
  3483. }
  3484. static struct md_sysfs_entry md_sync_completed = __ATTR_RO(sync_completed);
  3485. static ssize_t
  3486. min_sync_show(mddev_t *mddev, char *page)
  3487. {
  3488. return sprintf(page, "%llu\n",
  3489. (unsigned long long)mddev->resync_min);
  3490. }
  3491. static ssize_t
  3492. min_sync_store(mddev_t *mddev, const char *buf, size_t len)
  3493. {
  3494. unsigned long long min;
  3495. if (strict_strtoull(buf, 10, &min))
  3496. return -EINVAL;
  3497. if (min > mddev->resync_max)
  3498. return -EINVAL;
  3499. if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
  3500. return -EBUSY;
  3501. /* Must be a multiple of chunk_size */
  3502. if (mddev->chunk_sectors) {
  3503. sector_t temp = min;
  3504. if (sector_div(temp, mddev->chunk_sectors))
  3505. return -EINVAL;
  3506. }
  3507. mddev->resync_min = min;
  3508. return len;
  3509. }
  3510. static struct md_sysfs_entry md_min_sync =
  3511. __ATTR(sync_min, S_IRUGO|S_IWUSR, min_sync_show, min_sync_store);
  3512. static ssize_t
  3513. max_sync_show(mddev_t *mddev, char *page)
  3514. {
  3515. if (mddev->resync_max == MaxSector)
  3516. return sprintf(page, "max\n");
  3517. else
  3518. return sprintf(page, "%llu\n",
  3519. (unsigned long long)mddev->resync_max);
  3520. }
  3521. static ssize_t
  3522. max_sync_store(mddev_t *mddev, const char *buf, size_t len)
  3523. {
  3524. if (strncmp(buf, "max", 3) == 0)
  3525. mddev->resync_max = MaxSector;
  3526. else {
  3527. unsigned long long max;
  3528. if (strict_strtoull(buf, 10, &max))
  3529. return -EINVAL;
  3530. if (max < mddev->resync_min)
  3531. return -EINVAL;
  3532. if (max < mddev->resync_max &&
  3533. mddev->ro == 0 &&
  3534. test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
  3535. return -EBUSY;
  3536. /* Must be a multiple of chunk_size */
  3537. if (mddev->chunk_sectors) {
  3538. sector_t temp = max;
  3539. if (sector_div(temp, mddev->chunk_sectors))
  3540. return -EINVAL;
  3541. }
  3542. mddev->resync_max = max;
  3543. }
  3544. wake_up(&mddev->recovery_wait);
  3545. return len;
  3546. }
  3547. static struct md_sysfs_entry md_max_sync =
  3548. __ATTR(sync_max, S_IRUGO|S_IWUSR, max_sync_show, max_sync_store);
  3549. static ssize_t
  3550. suspend_lo_show(mddev_t *mddev, char *page)
  3551. {
  3552. return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_lo);
  3553. }
  3554. static ssize_t
  3555. suspend_lo_store(mddev_t *mddev, const char *buf, size_t len)
  3556. {
  3557. char *e;
  3558. unsigned long long new = simple_strtoull(buf, &e, 10);
  3559. if (mddev->pers == NULL ||
  3560. mddev->pers->quiesce == NULL)
  3561. return -EINVAL;
  3562. if (buf == e || (*e && *e != '\n'))
  3563. return -EINVAL;
  3564. if (new >= mddev->suspend_hi ||
  3565. (new > mddev->suspend_lo && new < mddev->suspend_hi)) {
  3566. mddev->suspend_lo = new;
  3567. mddev->pers->quiesce(mddev, 2);
  3568. return len;
  3569. } else
  3570. return -EINVAL;
  3571. }
  3572. static struct md_sysfs_entry md_suspend_lo =
  3573. __ATTR(suspend_lo, S_IRUGO|S_IWUSR, suspend_lo_show, suspend_lo_store);
  3574. static ssize_t
  3575. suspend_hi_show(mddev_t *mddev, char *page)
  3576. {
  3577. return sprintf(page, "%llu\n", (unsigned long long)mddev->suspend_hi);
  3578. }
  3579. static ssize_t
  3580. suspend_hi_store(mddev_t *mddev, const char *buf, size_t len)
  3581. {
  3582. char *e;
  3583. unsigned long long new = simple_strtoull(buf, &e, 10);
  3584. if (mddev->pers == NULL ||
  3585. mddev->pers->quiesce == NULL)
  3586. return -EINVAL;
  3587. if (buf == e || (*e && *e != '\n'))
  3588. return -EINVAL;
  3589. if ((new <= mddev->suspend_lo && mddev->suspend_lo >= mddev->suspend_hi) ||
  3590. (new > mddev->suspend_lo && new > mddev->suspend_hi)) {
  3591. mddev->suspend_hi = new;
  3592. mddev->pers->quiesce(mddev, 1);
  3593. mddev->pers->quiesce(mddev, 0);
  3594. return len;
  3595. } else
  3596. return -EINVAL;
  3597. }
  3598. static struct md_sysfs_entry md_suspend_hi =
  3599. __ATTR(suspend_hi, S_IRUGO|S_IWUSR, suspend_hi_show, suspend_hi_store);
  3600. static ssize_t
  3601. reshape_position_show(mddev_t *mddev, char *page)
  3602. {
  3603. if (mddev->reshape_position != MaxSector)
  3604. return sprintf(page, "%llu\n",
  3605. (unsigned long long)mddev->reshape_position);
  3606. strcpy(page, "none\n");
  3607. return 5;
  3608. }
  3609. static ssize_t
  3610. reshape_position_store(mddev_t *mddev, const char *buf, size_t len)
  3611. {
  3612. char *e;
  3613. unsigned long long new = simple_strtoull(buf, &e, 10);
  3614. if (mddev->pers)
  3615. return -EBUSY;
  3616. if (buf == e || (*e && *e != '\n'))
  3617. return -EINVAL;
  3618. mddev->reshape_position = new;
  3619. mddev->delta_disks = 0;
  3620. mddev->new_level = mddev->level;
  3621. mddev->new_layout = mddev->layout;
  3622. mddev->new_chunk_sectors = mddev->chunk_sectors;
  3623. return len;
  3624. }
  3625. static struct md_sysfs_entry md_reshape_position =
  3626. __ATTR(reshape_position, S_IRUGO|S_IWUSR, reshape_position_show,
  3627. reshape_position_store);
  3628. static ssize_t
  3629. array_size_show(mddev_t *mddev, char *page)
  3630. {
  3631. if (mddev->external_size)
  3632. return sprintf(page, "%llu\n",
  3633. (unsigned long long)mddev->array_sectors/2);
  3634. else
  3635. return sprintf(page, "default\n");
  3636. }
  3637. static ssize_t
  3638. array_size_store(mddev_t *mddev, const char *buf, size_t len)
  3639. {
  3640. sector_t sectors;
  3641. if (strncmp(buf, "default", 7) == 0) {
  3642. if (mddev->pers)
  3643. sectors = mddev->pers->size(mddev, 0, 0);
  3644. else
  3645. sectors = mddev->array_sectors;
  3646. mddev->external_size = 0;
  3647. } else {
  3648. if (strict_blocks_to_sectors(buf, &sectors) < 0)
  3649. return -EINVAL;
  3650. if (mddev->pers && mddev->pers->size(mddev, 0, 0) < sectors)
  3651. return -E2BIG;
  3652. mddev->external_size = 1;
  3653. }
  3654. mddev->array_sectors = sectors;
  3655. set_capacity(mddev->gendisk, mddev->array_sectors);
  3656. if (mddev->pers)
  3657. revalidate_disk(mddev->gendisk);
  3658. return len;
  3659. }
  3660. static struct md_sysfs_entry md_array_size =
  3661. __ATTR(array_size, S_IRUGO|S_IWUSR, array_size_show,
  3662. array_size_store);
  3663. static struct attribute *md_default_attrs[] = {
  3664. &md_level.attr,
  3665. &md_layout.attr,
  3666. &md_raid_disks.attr,
  3667. &md_chunk_size.attr,
  3668. &md_size.attr,
  3669. &md_resync_start.attr,
  3670. &md_metadata.attr,
  3671. &md_new_device.attr,
  3672. &md_safe_delay.attr,
  3673. &md_array_state.attr,
  3674. &md_reshape_position.attr,
  3675. &md_array_size.attr,
  3676. &max_corr_read_errors.attr,
  3677. NULL,
  3678. };
  3679. static struct attribute *md_redundancy_attrs[] = {
  3680. &md_scan_mode.attr,
  3681. &md_mismatches.attr,
  3682. &md_sync_min.attr,
  3683. &md_sync_max.attr,
  3684. &md_sync_speed.attr,
  3685. &md_sync_force_parallel.attr,
  3686. &md_sync_completed.attr,
  3687. &md_min_sync.attr,
  3688. &md_max_sync.attr,
  3689. &md_suspend_lo.attr,
  3690. &md_suspend_hi.attr,
  3691. &md_bitmap.attr,
  3692. &md_degraded.attr,
  3693. NULL,
  3694. };
  3695. static struct attribute_group md_redundancy_group = {
  3696. .name = NULL,
  3697. .attrs = md_redundancy_attrs,
  3698. };
  3699. static ssize_t
  3700. md_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
  3701. {
  3702. struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
  3703. mddev_t *mddev = container_of(kobj, struct mddev_s, kobj);
  3704. ssize_t rv;
  3705. if (!entry->show)
  3706. return -EIO;
  3707. rv = mddev_lock(mddev);
  3708. if (!rv) {
  3709. rv = entry->show(mddev, page);
  3710. mddev_unlock(mddev);
  3711. }
  3712. return rv;
  3713. }
  3714. static ssize_t
  3715. md_attr_store(struct kobject *kobj, struct attribute *attr,
  3716. const char *page, size_t length)
  3717. {
  3718. struct md_sysfs_entry *entry = container_of(attr, struct md_sysfs_entry, attr);
  3719. mddev_t *mddev = container_of(kobj, struct mddev_s, kobj);
  3720. ssize_t rv;
  3721. if (!entry->store)
  3722. return -EIO;
  3723. if (!capable(CAP_SYS_ADMIN))
  3724. return -EACCES;
  3725. rv = mddev_lock(mddev);
  3726. if (mddev->hold_active == UNTIL_IOCTL)
  3727. mddev->hold_active = 0;
  3728. if (!rv) {
  3729. rv = entry->store(mddev, page, length);
  3730. mddev_unlock(mddev);
  3731. }
  3732. return rv;
  3733. }
  3734. static void md_free(struct kobject *ko)
  3735. {
  3736. mddev_t *mddev = container_of(ko, mddev_t, kobj);
  3737. if (mddev->sysfs_state)
  3738. sysfs_put(mddev->sysfs_state);
  3739. if (mddev->gendisk) {
  3740. del_gendisk(mddev->gendisk);
  3741. put_disk(mddev->gendisk);
  3742. }
  3743. if (mddev->queue)
  3744. blk_cleanup_queue(mddev->queue);
  3745. kfree(mddev);
  3746. }
  3747. static const struct sysfs_ops md_sysfs_ops = {
  3748. .show = md_attr_show,
  3749. .store = md_attr_store,
  3750. };
  3751. static struct kobj_type md_ktype = {
  3752. .release = md_free,
  3753. .sysfs_ops = &md_sysfs_ops,
  3754. .default_attrs = md_default_attrs,
  3755. };
  3756. int mdp_major = 0;
  3757. static void mddev_delayed_delete(struct work_struct *ws)
  3758. {
  3759. mddev_t *mddev = container_of(ws, mddev_t, del_work);
  3760. sysfs_remove_group(&mddev->kobj, &md_bitmap_group);
  3761. kobject_del(&mddev->kobj);
  3762. kobject_put(&mddev->kobj);
  3763. }
  3764. static int md_alloc(dev_t dev, char *name)
  3765. {
  3766. static DEFINE_MUTEX(disks_mutex);
  3767. mddev_t *mddev = mddev_find(dev);
  3768. struct gendisk *disk;
  3769. int partitioned;
  3770. int shift;
  3771. int unit;
  3772. int error;
  3773. if (!mddev)
  3774. return -ENODEV;
  3775. partitioned = (MAJOR(mddev->unit) != MD_MAJOR);
  3776. shift = partitioned ? MdpMinorShift : 0;
  3777. unit = MINOR(mddev->unit) >> shift;
  3778. /* wait for any previous instance if this device
  3779. * to be completed removed (mddev_delayed_delete).
  3780. */
  3781. flush_scheduled_work();
  3782. mutex_lock(&disks_mutex);
  3783. error = -EEXIST;
  3784. if (mddev->gendisk)
  3785. goto abort;
  3786. if (name) {
  3787. /* Need to ensure that 'name' is not a duplicate.
  3788. */
  3789. mddev_t *mddev2;
  3790. spin_lock(&all_mddevs_lock);
  3791. list_for_each_entry(mddev2, &all_mddevs, all_mddevs)
  3792. if (mddev2->gendisk &&
  3793. strcmp(mddev2->gendisk->disk_name, name) == 0) {
  3794. spin_unlock(&all_mddevs_lock);
  3795. goto abort;
  3796. }
  3797. spin_unlock(&all_mddevs_lock);
  3798. }
  3799. error = -ENOMEM;
  3800. mddev->queue = blk_alloc_queue(GFP_KERNEL);
  3801. if (!mddev->queue)
  3802. goto abort;
  3803. mddev->queue->queuedata = mddev;
  3804. /* Can be unlocked because the queue is new: no concurrency */
  3805. queue_flag_set_unlocked(QUEUE_FLAG_CLUSTER, mddev->queue);
  3806. blk_queue_make_request(mddev->queue, md_make_request);
  3807. disk = alloc_disk(1 << shift);
  3808. if (!disk) {
  3809. blk_cleanup_queue(mddev->queue);
  3810. mddev->queue = NULL;
  3811. goto abort;
  3812. }
  3813. disk->major = MAJOR(mddev->unit);
  3814. disk->first_minor = unit << shift;
  3815. if (name)
  3816. strcpy(disk->disk_name, name);
  3817. else if (partitioned)
  3818. sprintf(disk->disk_name, "md_d%d", unit);
  3819. else
  3820. sprintf(disk->disk_name, "md%d", unit);
  3821. disk->fops = &md_fops;
  3822. disk->private_data = mddev;
  3823. disk->queue = mddev->queue;
  3824. /* Allow extended partitions. This makes the
  3825. * 'mdp' device redundant, but we can't really
  3826. * remove it now.
  3827. */
  3828. disk->flags |= GENHD_FL_EXT_DEVT;
  3829. add_disk(disk);
  3830. mddev->gendisk = disk;
  3831. error = kobject_init_and_add(&mddev->kobj, &md_ktype,
  3832. &disk_to_dev(disk)->kobj, "%s", "md");
  3833. if (error) {
  3834. /* This isn't possible, but as kobject_init_and_add is marked
  3835. * __must_check, we must do something with the result
  3836. */
  3837. printk(KERN_WARNING "md: cannot register %s/md - name in use\n",
  3838. disk->disk_name);
  3839. error = 0;
  3840. }
  3841. if (mddev->kobj.sd &&
  3842. sysfs_create_group(&mddev->kobj, &md_bitmap_group))
  3843. printk(KERN_DEBUG "pointless warning\n");
  3844. abort:
  3845. mutex_unlock(&disks_mutex);
  3846. if (!error && mddev->kobj.sd) {
  3847. kobject_uevent(&mddev->kobj, KOBJ_ADD);
  3848. mddev->sysfs_state = sysfs_get_dirent_safe(mddev->kobj.sd, "array_state");
  3849. }
  3850. mddev_put(mddev);
  3851. return error;
  3852. }
  3853. static struct kobject *md_probe(dev_t dev, int *part, void *data)
  3854. {
  3855. md_alloc(dev, NULL);
  3856. return NULL;
  3857. }
  3858. static int add_named_array(const char *val, struct kernel_param *kp)
  3859. {
  3860. /* val must be "md_*" where * is not all digits.
  3861. * We allocate an array with a large free minor number, and
  3862. * set the name to val. val must not already be an active name.
  3863. */
  3864. int len = strlen(val);
  3865. char buf[DISK_NAME_LEN];
  3866. while (len && val[len-1] == '\n')
  3867. len--;
  3868. if (len >= DISK_NAME_LEN)
  3869. return -E2BIG;
  3870. strlcpy(buf, val, len+1);
  3871. if (strncmp(buf, "md_", 3) != 0)
  3872. return -EINVAL;
  3873. return md_alloc(0, buf);
  3874. }
  3875. static void md_safemode_timeout(unsigned long data)
  3876. {
  3877. mddev_t *mddev = (mddev_t *) data;
  3878. if (!atomic_read(&mddev->writes_pending)) {
  3879. mddev->safemode = 1;
  3880. if (mddev->external)
  3881. sysfs_notify_dirent_safe(mddev->sysfs_state);
  3882. }
  3883. md_wakeup_thread(mddev->thread);
  3884. }
  3885. static int start_dirty_degraded;
  3886. int md_run(mddev_t *mddev)
  3887. {
  3888. int err;
  3889. mdk_rdev_t *rdev;
  3890. struct mdk_personality *pers;
  3891. if (list_empty(&mddev->disks))
  3892. /* cannot run an array with no devices.. */
  3893. return -EINVAL;
  3894. if (mddev->pers)
  3895. return -EBUSY;
  3896. /* Cannot run until previous stop completes properly */
  3897. if (mddev->sysfs_active)
  3898. return -EBUSY;
  3899. /*
  3900. * Analyze all RAID superblock(s)
  3901. */
  3902. if (!mddev->raid_disks) {
  3903. if (!mddev->persistent)
  3904. return -EINVAL;
  3905. analyze_sbs(mddev);
  3906. }
  3907. if (mddev->level != LEVEL_NONE)
  3908. request_module("md-level-%d", mddev->level);
  3909. else if (mddev->clevel[0])
  3910. request_module("md-%s", mddev->clevel);
  3911. /*
  3912. * Drop all container device buffers, from now on
  3913. * the only valid external interface is through the md
  3914. * device.
  3915. */
  3916. list_for_each_entry(rdev, &mddev->disks, same_set) {
  3917. if (test_bit(Faulty, &rdev->flags))
  3918. continue;
  3919. sync_blockdev(rdev->bdev);
  3920. invalidate_bdev(rdev->bdev);
  3921. /* perform some consistency tests on the device.
  3922. * We don't want the data to overlap the metadata,
  3923. * Internal Bitmap issues have been handled elsewhere.
  3924. */
  3925. if (rdev->data_offset < rdev->sb_start) {
  3926. if (mddev->dev_sectors &&
  3927. rdev->data_offset + mddev->dev_sectors
  3928. > rdev->sb_start) {
  3929. printk("md: %s: data overlaps metadata\n",
  3930. mdname(mddev));
  3931. return -EINVAL;
  3932. }
  3933. } else {
  3934. if (rdev->sb_start + rdev->sb_size/512
  3935. > rdev->data_offset) {
  3936. printk("md: %s: metadata overlaps data\n",
  3937. mdname(mddev));
  3938. return -EINVAL;
  3939. }
  3940. }
  3941. sysfs_notify_dirent_safe(rdev->sysfs_state);
  3942. }
  3943. spin_lock(&pers_lock);
  3944. pers = find_pers(mddev->level, mddev->clevel);
  3945. if (!pers || !try_module_get(pers->owner)) {
  3946. spin_unlock(&pers_lock);
  3947. if (mddev->level != LEVEL_NONE)
  3948. printk(KERN_WARNING "md: personality for level %d is not loaded!\n",
  3949. mddev->level);
  3950. else
  3951. printk(KERN_WARNING "md: personality for level %s is not loaded!\n",
  3952. mddev->clevel);
  3953. return -EINVAL;
  3954. }
  3955. mddev->pers = pers;
  3956. spin_unlock(&pers_lock);
  3957. if (mddev->level != pers->level) {
  3958. mddev->level = pers->level;
  3959. mddev->new_level = pers->level;
  3960. }
  3961. strlcpy(mddev->clevel, pers->name, sizeof(mddev->clevel));
  3962. if (mddev->reshape_position != MaxSector &&
  3963. pers->start_reshape == NULL) {
  3964. /* This personality cannot handle reshaping... */
  3965. mddev->pers = NULL;
  3966. module_put(pers->owner);
  3967. return -EINVAL;
  3968. }
  3969. if (pers->sync_request) {
  3970. /* Warn if this is a potentially silly
  3971. * configuration.
  3972. */
  3973. char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
  3974. mdk_rdev_t *rdev2;
  3975. int warned = 0;
  3976. list_for_each_entry(rdev, &mddev->disks, same_set)
  3977. list_for_each_entry(rdev2, &mddev->disks, same_set) {
  3978. if (rdev < rdev2 &&
  3979. rdev->bdev->bd_contains ==
  3980. rdev2->bdev->bd_contains) {
  3981. printk(KERN_WARNING
  3982. "%s: WARNING: %s appears to be"
  3983. " on the same physical disk as"
  3984. " %s.\n",
  3985. mdname(mddev),
  3986. bdevname(rdev->bdev,b),
  3987. bdevname(rdev2->bdev,b2));
  3988. warned = 1;
  3989. }
  3990. }
  3991. if (warned)
  3992. printk(KERN_WARNING
  3993. "True protection against single-disk"
  3994. " failure might be compromised.\n");
  3995. }
  3996. mddev->recovery = 0;
  3997. /* may be over-ridden by personality */
  3998. mddev->resync_max_sectors = mddev->dev_sectors;
  3999. mddev->barriers_work = 1;
  4000. mddev->ok_start_degraded = start_dirty_degraded;
  4001. if (start_readonly && mddev->ro == 0)
  4002. mddev->ro = 2; /* read-only, but switch on first write */
  4003. err = mddev->pers->run(mddev);
  4004. if (err)
  4005. printk(KERN_ERR "md: pers->run() failed ...\n");
  4006. else if (mddev->pers->size(mddev, 0, 0) < mddev->array_sectors) {
  4007. WARN_ONCE(!mddev->external_size, "%s: default size too small,"
  4008. " but 'external_size' not in effect?\n", __func__);
  4009. printk(KERN_ERR
  4010. "md: invalid array_size %llu > default size %llu\n",
  4011. (unsigned long long)mddev->array_sectors / 2,
  4012. (unsigned long long)mddev->pers->size(mddev, 0, 0) / 2);
  4013. err = -EINVAL;
  4014. mddev->pers->stop(mddev);
  4015. }
  4016. if (err == 0 && mddev->pers->sync_request) {
  4017. err = bitmap_create(mddev);
  4018. if (err) {
  4019. printk(KERN_ERR "%s: failed to create bitmap (%d)\n",
  4020. mdname(mddev), err);
  4021. mddev->pers->stop(mddev);
  4022. }
  4023. }
  4024. if (err) {
  4025. module_put(mddev->pers->owner);
  4026. mddev->pers = NULL;
  4027. bitmap_destroy(mddev);
  4028. return err;
  4029. }
  4030. if (mddev->pers->sync_request) {
  4031. if (mddev->kobj.sd &&
  4032. sysfs_create_group(&mddev->kobj, &md_redundancy_group))
  4033. printk(KERN_WARNING
  4034. "md: cannot register extra attributes for %s\n",
  4035. mdname(mddev));
  4036. mddev->sysfs_action = sysfs_get_dirent_safe(mddev->kobj.sd, "sync_action");
  4037. } else if (mddev->ro == 2) /* auto-readonly not meaningful */
  4038. mddev->ro = 0;
  4039. atomic_set(&mddev->writes_pending,0);
  4040. atomic_set(&mddev->max_corr_read_errors,
  4041. MD_DEFAULT_MAX_CORRECTED_READ_ERRORS);
  4042. mddev->safemode = 0;
  4043. mddev->safemode_timer.function = md_safemode_timeout;
  4044. mddev->safemode_timer.data = (unsigned long) mddev;
  4045. mddev->safemode_delay = (200 * HZ)/1000 +1; /* 200 msec delay */
  4046. mddev->in_sync = 1;
  4047. list_for_each_entry(rdev, &mddev->disks, same_set)
  4048. if (rdev->raid_disk >= 0) {
  4049. char nm[20];
  4050. sprintf(nm, "rd%d", rdev->raid_disk);
  4051. if (sysfs_create_link(&mddev->kobj, &rdev->kobj, nm))
  4052. /* failure here is OK */;
  4053. }
  4054. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  4055. if (mddev->flags)
  4056. md_update_sb(mddev, 0);
  4057. md_wakeup_thread(mddev->thread);
  4058. md_wakeup_thread(mddev->sync_thread); /* possibly kick off a reshape */
  4059. md_new_event(mddev);
  4060. sysfs_notify_dirent_safe(mddev->sysfs_state);
  4061. sysfs_notify_dirent_safe(mddev->sysfs_action);
  4062. sysfs_notify(&mddev->kobj, NULL, "degraded");
  4063. return 0;
  4064. }
  4065. EXPORT_SYMBOL_GPL(md_run);
  4066. static int do_md_run(mddev_t *mddev)
  4067. {
  4068. int err;
  4069. err = md_run(mddev);
  4070. if (err)
  4071. goto out;
  4072. err = bitmap_load(mddev);
  4073. if (err) {
  4074. bitmap_destroy(mddev);
  4075. goto out;
  4076. }
  4077. set_capacity(mddev->gendisk, mddev->array_sectors);
  4078. revalidate_disk(mddev->gendisk);
  4079. kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
  4080. out:
  4081. return err;
  4082. }
  4083. static int restart_array(mddev_t *mddev)
  4084. {
  4085. struct gendisk *disk = mddev->gendisk;
  4086. /* Complain if it has no devices */
  4087. if (list_empty(&mddev->disks))
  4088. return -ENXIO;
  4089. if (!mddev->pers)
  4090. return -EINVAL;
  4091. if (!mddev->ro)
  4092. return -EBUSY;
  4093. mddev->safemode = 0;
  4094. mddev->ro = 0;
  4095. set_disk_ro(disk, 0);
  4096. printk(KERN_INFO "md: %s switched to read-write mode.\n",
  4097. mdname(mddev));
  4098. /* Kick recovery or resync if necessary */
  4099. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  4100. md_wakeup_thread(mddev->thread);
  4101. md_wakeup_thread(mddev->sync_thread);
  4102. sysfs_notify_dirent_safe(mddev->sysfs_state);
  4103. return 0;
  4104. }
  4105. /* similar to deny_write_access, but accounts for our holding a reference
  4106. * to the file ourselves */
  4107. static int deny_bitmap_write_access(struct file * file)
  4108. {
  4109. struct inode *inode = file->f_mapping->host;
  4110. spin_lock(&inode->i_lock);
  4111. if (atomic_read(&inode->i_writecount) > 1) {
  4112. spin_unlock(&inode->i_lock);
  4113. return -ETXTBSY;
  4114. }
  4115. atomic_set(&inode->i_writecount, -1);
  4116. spin_unlock(&inode->i_lock);
  4117. return 0;
  4118. }
  4119. void restore_bitmap_write_access(struct file *file)
  4120. {
  4121. struct inode *inode = file->f_mapping->host;
  4122. spin_lock(&inode->i_lock);
  4123. atomic_set(&inode->i_writecount, 1);
  4124. spin_unlock(&inode->i_lock);
  4125. }
  4126. static void md_clean(mddev_t *mddev)
  4127. {
  4128. mddev->array_sectors = 0;
  4129. mddev->external_size = 0;
  4130. mddev->dev_sectors = 0;
  4131. mddev->raid_disks = 0;
  4132. mddev->recovery_cp = 0;
  4133. mddev->resync_min = 0;
  4134. mddev->resync_max = MaxSector;
  4135. mddev->reshape_position = MaxSector;
  4136. mddev->external = 0;
  4137. mddev->persistent = 0;
  4138. mddev->level = LEVEL_NONE;
  4139. mddev->clevel[0] = 0;
  4140. mddev->flags = 0;
  4141. mddev->ro = 0;
  4142. mddev->metadata_type[0] = 0;
  4143. mddev->chunk_sectors = 0;
  4144. mddev->ctime = mddev->utime = 0;
  4145. mddev->layout = 0;
  4146. mddev->max_disks = 0;
  4147. mddev->events = 0;
  4148. mddev->can_decrease_events = 0;
  4149. mddev->delta_disks = 0;
  4150. mddev->new_level = LEVEL_NONE;
  4151. mddev->new_layout = 0;
  4152. mddev->new_chunk_sectors = 0;
  4153. mddev->curr_resync = 0;
  4154. mddev->resync_mismatches = 0;
  4155. mddev->suspend_lo = mddev->suspend_hi = 0;
  4156. mddev->sync_speed_min = mddev->sync_speed_max = 0;
  4157. mddev->recovery = 0;
  4158. mddev->in_sync = 0;
  4159. mddev->degraded = 0;
  4160. mddev->barriers_work = 0;
  4161. mddev->safemode = 0;
  4162. mddev->bitmap_info.offset = 0;
  4163. mddev->bitmap_info.default_offset = 0;
  4164. mddev->bitmap_info.chunksize = 0;
  4165. mddev->bitmap_info.daemon_sleep = 0;
  4166. mddev->bitmap_info.max_write_behind = 0;
  4167. mddev->plug = NULL;
  4168. }
  4169. void md_stop_writes(mddev_t *mddev)
  4170. {
  4171. if (mddev->sync_thread) {
  4172. set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
  4173. set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  4174. md_unregister_thread(mddev->sync_thread);
  4175. mddev->sync_thread = NULL;
  4176. }
  4177. del_timer_sync(&mddev->safemode_timer);
  4178. bitmap_flush(mddev);
  4179. md_super_wait(mddev);
  4180. if (!mddev->in_sync || mddev->flags) {
  4181. /* mark array as shutdown cleanly */
  4182. mddev->in_sync = 1;
  4183. md_update_sb(mddev, 1);
  4184. }
  4185. }
  4186. EXPORT_SYMBOL_GPL(md_stop_writes);
  4187. void md_stop(mddev_t *mddev)
  4188. {
  4189. mddev->pers->stop(mddev);
  4190. if (mddev->pers->sync_request && mddev->to_remove == NULL)
  4191. mddev->to_remove = &md_redundancy_group;
  4192. module_put(mddev->pers->owner);
  4193. mddev->pers = NULL;
  4194. clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
  4195. }
  4196. EXPORT_SYMBOL_GPL(md_stop);
  4197. static int md_set_readonly(mddev_t *mddev, int is_open)
  4198. {
  4199. int err = 0;
  4200. mutex_lock(&mddev->open_mutex);
  4201. if (atomic_read(&mddev->openers) > is_open) {
  4202. printk("md: %s still in use.\n",mdname(mddev));
  4203. err = -EBUSY;
  4204. goto out;
  4205. }
  4206. if (mddev->pers) {
  4207. md_stop_writes(mddev);
  4208. err = -ENXIO;
  4209. if (mddev->ro==1)
  4210. goto out;
  4211. mddev->ro = 1;
  4212. set_disk_ro(mddev->gendisk, 1);
  4213. clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
  4214. sysfs_notify_dirent_safe(mddev->sysfs_state);
  4215. err = 0;
  4216. }
  4217. out:
  4218. mutex_unlock(&mddev->open_mutex);
  4219. return err;
  4220. }
  4221. /* mode:
  4222. * 0 - completely stop and dis-assemble array
  4223. * 2 - stop but do not disassemble array
  4224. */
  4225. static int do_md_stop(mddev_t * mddev, int mode, int is_open)
  4226. {
  4227. struct gendisk *disk = mddev->gendisk;
  4228. mdk_rdev_t *rdev;
  4229. mutex_lock(&mddev->open_mutex);
  4230. if (atomic_read(&mddev->openers) > is_open ||
  4231. mddev->sysfs_active) {
  4232. printk("md: %s still in use.\n",mdname(mddev));
  4233. mutex_unlock(&mddev->open_mutex);
  4234. return -EBUSY;
  4235. }
  4236. if (mddev->pers) {
  4237. if (mddev->ro)
  4238. set_disk_ro(disk, 0);
  4239. md_stop_writes(mddev);
  4240. md_stop(mddev);
  4241. mddev->queue->merge_bvec_fn = NULL;
  4242. mddev->queue->unplug_fn = NULL;
  4243. mddev->queue->backing_dev_info.congested_fn = NULL;
  4244. /* tell userspace to handle 'inactive' */
  4245. sysfs_notify_dirent_safe(mddev->sysfs_state);
  4246. list_for_each_entry(rdev, &mddev->disks, same_set)
  4247. if (rdev->raid_disk >= 0) {
  4248. char nm[20];
  4249. sprintf(nm, "rd%d", rdev->raid_disk);
  4250. sysfs_remove_link(&mddev->kobj, nm);
  4251. }
  4252. set_capacity(disk, 0);
  4253. mutex_unlock(&mddev->open_mutex);
  4254. revalidate_disk(disk);
  4255. if (mddev->ro)
  4256. mddev->ro = 0;
  4257. } else
  4258. mutex_unlock(&mddev->open_mutex);
  4259. /*
  4260. * Free resources if final stop
  4261. */
  4262. if (mode == 0) {
  4263. printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));
  4264. bitmap_destroy(mddev);
  4265. if (mddev->bitmap_info.file) {
  4266. restore_bitmap_write_access(mddev->bitmap_info.file);
  4267. fput(mddev->bitmap_info.file);
  4268. mddev->bitmap_info.file = NULL;
  4269. }
  4270. mddev->bitmap_info.offset = 0;
  4271. export_array(mddev);
  4272. md_clean(mddev);
  4273. kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);
  4274. if (mddev->hold_active == UNTIL_STOP)
  4275. mddev->hold_active = 0;
  4276. }
  4277. blk_integrity_unregister(disk);
  4278. md_new_event(mddev);
  4279. sysfs_notify_dirent_safe(mddev->sysfs_state);
  4280. return 0;
  4281. }
  4282. #ifndef MODULE
  4283. static void autorun_array(mddev_t *mddev)
  4284. {
  4285. mdk_rdev_t *rdev;
  4286. int err;
  4287. if (list_empty(&mddev->disks))
  4288. return;
  4289. printk(KERN_INFO "md: running: ");
  4290. list_for_each_entry(rdev, &mddev->disks, same_set) {
  4291. char b[BDEVNAME_SIZE];
  4292. printk("<%s>", bdevname(rdev->bdev,b));
  4293. }
  4294. printk("\n");
  4295. err = do_md_run(mddev);
  4296. if (err) {
  4297. printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
  4298. do_md_stop(mddev, 0, 0);
  4299. }
  4300. }
  4301. /*
  4302. * lets try to run arrays based on all disks that have arrived
  4303. * until now. (those are in pending_raid_disks)
  4304. *
  4305. * the method: pick the first pending disk, collect all disks with
  4306. * the same UUID, remove all from the pending list and put them into
  4307. * the 'same_array' list. Then order this list based on superblock
  4308. * update time (freshest comes first), kick out 'old' disks and
  4309. * compare superblocks. If everything's fine then run it.
  4310. *
  4311. * If "unit" is allocated, then bump its reference count
  4312. */
  4313. static void autorun_devices(int part)
  4314. {
  4315. mdk_rdev_t *rdev0, *rdev, *tmp;
  4316. mddev_t *mddev;
  4317. char b[BDEVNAME_SIZE];
  4318. printk(KERN_INFO "md: autorun ...\n");
  4319. while (!list_empty(&pending_raid_disks)) {
  4320. int unit;
  4321. dev_t dev;
  4322. LIST_HEAD(candidates);
  4323. rdev0 = list_entry(pending_raid_disks.next,
  4324. mdk_rdev_t, same_set);
  4325. printk(KERN_INFO "md: considering %s ...\n",
  4326. bdevname(rdev0->bdev,b));
  4327. INIT_LIST_HEAD(&candidates);
  4328. rdev_for_each_list(rdev, tmp, &pending_raid_disks)
  4329. if (super_90_load(rdev, rdev0, 0) >= 0) {
  4330. printk(KERN_INFO "md: adding %s ...\n",
  4331. bdevname(rdev->bdev,b));
  4332. list_move(&rdev->same_set, &candidates);
  4333. }
  4334. /*
  4335. * now we have a set of devices, with all of them having
  4336. * mostly sane superblocks. It's time to allocate the
  4337. * mddev.
  4338. */
  4339. if (part) {
  4340. dev = MKDEV(mdp_major,
  4341. rdev0->preferred_minor << MdpMinorShift);
  4342. unit = MINOR(dev) >> MdpMinorShift;
  4343. } else {
  4344. dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
  4345. unit = MINOR(dev);
  4346. }
  4347. if (rdev0->preferred_minor != unit) {
  4348. printk(KERN_INFO "md: unit number in %s is bad: %d\n",
  4349. bdevname(rdev0->bdev, b), rdev0->preferred_minor);
  4350. break;
  4351. }
  4352. md_probe(dev, NULL, NULL);
  4353. mddev = mddev_find(dev);
  4354. if (!mddev || !mddev->gendisk) {
  4355. if (mddev)
  4356. mddev_put(mddev);
  4357. printk(KERN_ERR
  4358. "md: cannot allocate memory for md drive.\n");
  4359. break;
  4360. }
  4361. if (mddev_lock(mddev))
  4362. printk(KERN_WARNING "md: %s locked, cannot run\n",
  4363. mdname(mddev));
  4364. else if (mddev->raid_disks || mddev->major_version
  4365. || !list_empty(&mddev->disks)) {
  4366. printk(KERN_WARNING
  4367. "md: %s already running, cannot run %s\n",
  4368. mdname(mddev), bdevname(rdev0->bdev,b));
  4369. mddev_unlock(mddev);
  4370. } else {
  4371. printk(KERN_INFO "md: created %s\n", mdname(mddev));
  4372. mddev->persistent = 1;
  4373. rdev_for_each_list(rdev, tmp, &candidates) {
  4374. list_del_init(&rdev->same_set);
  4375. if (bind_rdev_to_array(rdev, mddev))
  4376. export_rdev(rdev);
  4377. }
  4378. autorun_array(mddev);
  4379. mddev_unlock(mddev);
  4380. }
  4381. /* on success, candidates will be empty, on error
  4382. * it won't...
  4383. */
  4384. rdev_for_each_list(rdev, tmp, &candidates) {
  4385. list_del_init(&rdev->same_set);
  4386. export_rdev(rdev);
  4387. }
  4388. mddev_put(mddev);
  4389. }
  4390. printk(KERN_INFO "md: ... autorun DONE.\n");
  4391. }
  4392. #endif /* !MODULE */
  4393. static int get_version(void __user * arg)
  4394. {
  4395. mdu_version_t ver;
  4396. ver.major = MD_MAJOR_VERSION;
  4397. ver.minor = MD_MINOR_VERSION;
  4398. ver.patchlevel = MD_PATCHLEVEL_VERSION;
  4399. if (copy_to_user(arg, &ver, sizeof(ver)))
  4400. return -EFAULT;
  4401. return 0;
  4402. }
  4403. static int get_array_info(mddev_t * mddev, void __user * arg)
  4404. {
  4405. mdu_array_info_t info;
  4406. int nr,working,insync,failed,spare;
  4407. mdk_rdev_t *rdev;
  4408. nr=working=insync=failed=spare=0;
  4409. list_for_each_entry(rdev, &mddev->disks, same_set) {
  4410. nr++;
  4411. if (test_bit(Faulty, &rdev->flags))
  4412. failed++;
  4413. else {
  4414. working++;
  4415. if (test_bit(In_sync, &rdev->flags))
  4416. insync++;
  4417. else
  4418. spare++;
  4419. }
  4420. }
  4421. info.major_version = mddev->major_version;
  4422. info.minor_version = mddev->minor_version;
  4423. info.patch_version = MD_PATCHLEVEL_VERSION;
  4424. info.ctime = mddev->ctime;
  4425. info.level = mddev->level;
  4426. info.size = mddev->dev_sectors / 2;
  4427. if (info.size != mddev->dev_sectors / 2) /* overflow */
  4428. info.size = -1;
  4429. info.nr_disks = nr;
  4430. info.raid_disks = mddev->raid_disks;
  4431. info.md_minor = mddev->md_minor;
  4432. info.not_persistent= !mddev->persistent;
  4433. info.utime = mddev->utime;
  4434. info.state = 0;
  4435. if (mddev->in_sync)
  4436. info.state = (1<<MD_SB_CLEAN);
  4437. if (mddev->bitmap && mddev->bitmap_info.offset)
  4438. info.state = (1<<MD_SB_BITMAP_PRESENT);
  4439. info.active_disks = insync;
  4440. info.working_disks = working;
  4441. info.failed_disks = failed;
  4442. info.spare_disks = spare;
  4443. info.layout = mddev->layout;
  4444. info.chunk_size = mddev->chunk_sectors << 9;
  4445. if (copy_to_user(arg, &info, sizeof(info)))
  4446. return -EFAULT;
  4447. return 0;
  4448. }
  4449. static int get_bitmap_file(mddev_t * mddev, void __user * arg)
  4450. {
  4451. mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
  4452. char *ptr, *buf = NULL;
  4453. int err = -ENOMEM;
  4454. if (md_allow_write(mddev))
  4455. file = kmalloc(sizeof(*file), GFP_NOIO);
  4456. else
  4457. file = kmalloc(sizeof(*file), GFP_KERNEL);
  4458. if (!file)
  4459. goto out;
  4460. /* bitmap disabled, zero the first byte and copy out */
  4461. if (!mddev->bitmap || !mddev->bitmap->file) {
  4462. file->pathname[0] = '\0';
  4463. goto copy_out;
  4464. }
  4465. buf = kmalloc(sizeof(file->pathname), GFP_KERNEL);
  4466. if (!buf)
  4467. goto out;
  4468. ptr = d_path(&mddev->bitmap->file->f_path, buf, sizeof(file->pathname));
  4469. if (IS_ERR(ptr))
  4470. goto out;
  4471. strcpy(file->pathname, ptr);
  4472. copy_out:
  4473. err = 0;
  4474. if (copy_to_user(arg, file, sizeof(*file)))
  4475. err = -EFAULT;
  4476. out:
  4477. kfree(buf);
  4478. kfree(file);
  4479. return err;
  4480. }
  4481. static int get_disk_info(mddev_t * mddev, void __user * arg)
  4482. {
  4483. mdu_disk_info_t info;
  4484. mdk_rdev_t *rdev;
  4485. if (copy_from_user(&info, arg, sizeof(info)))
  4486. return -EFAULT;
  4487. rdev = find_rdev_nr(mddev, info.number);
  4488. if (rdev) {
  4489. info.major = MAJOR(rdev->bdev->bd_dev);
  4490. info.minor = MINOR(rdev->bdev->bd_dev);
  4491. info.raid_disk = rdev->raid_disk;
  4492. info.state = 0;
  4493. if (test_bit(Faulty, &rdev->flags))
  4494. info.state |= (1<<MD_DISK_FAULTY);
  4495. else if (test_bit(In_sync, &rdev->flags)) {
  4496. info.state |= (1<<MD_DISK_ACTIVE);
  4497. info.state |= (1<<MD_DISK_SYNC);
  4498. }
  4499. if (test_bit(WriteMostly, &rdev->flags))
  4500. info.state |= (1<<MD_DISK_WRITEMOSTLY);
  4501. } else {
  4502. info.major = info.minor = 0;
  4503. info.raid_disk = -1;
  4504. info.state = (1<<MD_DISK_REMOVED);
  4505. }
  4506. if (copy_to_user(arg, &info, sizeof(info)))
  4507. return -EFAULT;
  4508. return 0;
  4509. }
  4510. static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info)
  4511. {
  4512. char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
  4513. mdk_rdev_t *rdev;
  4514. dev_t dev = MKDEV(info->major,info->minor);
  4515. if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
  4516. return -EOVERFLOW;
  4517. if (!mddev->raid_disks) {
  4518. int err;
  4519. /* expecting a device which has a superblock */
  4520. rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
  4521. if (IS_ERR(rdev)) {
  4522. printk(KERN_WARNING
  4523. "md: md_import_device returned %ld\n",
  4524. PTR_ERR(rdev));
  4525. return PTR_ERR(rdev);
  4526. }
  4527. if (!list_empty(&mddev->disks)) {
  4528. mdk_rdev_t *rdev0 = list_entry(mddev->disks.next,
  4529. mdk_rdev_t, same_set);
  4530. err = super_types[mddev->major_version]
  4531. .load_super(rdev, rdev0, mddev->minor_version);
  4532. if (err < 0) {
  4533. printk(KERN_WARNING
  4534. "md: %s has different UUID to %s\n",
  4535. bdevname(rdev->bdev,b),
  4536. bdevname(rdev0->bdev,b2));
  4537. export_rdev(rdev);
  4538. return -EINVAL;
  4539. }
  4540. }
  4541. err = bind_rdev_to_array(rdev, mddev);
  4542. if (err)
  4543. export_rdev(rdev);
  4544. return err;
  4545. }
  4546. /*
  4547. * add_new_disk can be used once the array is assembled
  4548. * to add "hot spares". They must already have a superblock
  4549. * written
  4550. */
  4551. if (mddev->pers) {
  4552. int err;
  4553. if (!mddev->pers->hot_add_disk) {
  4554. printk(KERN_WARNING
  4555. "%s: personality does not support diskops!\n",
  4556. mdname(mddev));
  4557. return -EINVAL;
  4558. }
  4559. if (mddev->persistent)
  4560. rdev = md_import_device(dev, mddev->major_version,
  4561. mddev->minor_version);
  4562. else
  4563. rdev = md_import_device(dev, -1, -1);
  4564. if (IS_ERR(rdev)) {
  4565. printk(KERN_WARNING
  4566. "md: md_import_device returned %ld\n",
  4567. PTR_ERR(rdev));
  4568. return PTR_ERR(rdev);
  4569. }
  4570. /* set save_raid_disk if appropriate */
  4571. if (!mddev->persistent) {
  4572. if (info->state & (1<<MD_DISK_SYNC) &&
  4573. info->raid_disk < mddev->raid_disks)
  4574. rdev->raid_disk = info->raid_disk;
  4575. else
  4576. rdev->raid_disk = -1;
  4577. } else
  4578. super_types[mddev->major_version].
  4579. validate_super(mddev, rdev);
  4580. rdev->saved_raid_disk = rdev->raid_disk;
  4581. clear_bit(In_sync, &rdev->flags); /* just to be sure */
  4582. if (info->state & (1<<MD_DISK_WRITEMOSTLY))
  4583. set_bit(WriteMostly, &rdev->flags);
  4584. else
  4585. clear_bit(WriteMostly, &rdev->flags);
  4586. rdev->raid_disk = -1;
  4587. err = bind_rdev_to_array(rdev, mddev);
  4588. if (!err && !mddev->pers->hot_remove_disk) {
  4589. /* If there is hot_add_disk but no hot_remove_disk
  4590. * then added disks for geometry changes,
  4591. * and should be added immediately.
  4592. */
  4593. super_types[mddev->major_version].
  4594. validate_super(mddev, rdev);
  4595. err = mddev->pers->hot_add_disk(mddev, rdev);
  4596. if (err)
  4597. unbind_rdev_from_array(rdev);
  4598. }
  4599. if (err)
  4600. export_rdev(rdev);
  4601. else
  4602. sysfs_notify_dirent_safe(rdev->sysfs_state);
  4603. md_update_sb(mddev, 1);
  4604. if (mddev->degraded)
  4605. set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
  4606. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  4607. md_wakeup_thread(mddev->thread);
  4608. return err;
  4609. }
  4610. /* otherwise, add_new_disk is only allowed
  4611. * for major_version==0 superblocks
  4612. */
  4613. if (mddev->major_version != 0) {
  4614. printk(KERN_WARNING "%s: ADD_NEW_DISK not supported\n",
  4615. mdname(mddev));
  4616. return -EINVAL;
  4617. }
  4618. if (!(info->state & (1<<MD_DISK_FAULTY))) {
  4619. int err;
  4620. rdev = md_import_device(dev, -1, 0);
  4621. if (IS_ERR(rdev)) {
  4622. printk(KERN_WARNING
  4623. "md: error, md_import_device() returned %ld\n",
  4624. PTR_ERR(rdev));
  4625. return PTR_ERR(rdev);
  4626. }
  4627. rdev->desc_nr = info->number;
  4628. if (info->raid_disk < mddev->raid_disks)
  4629. rdev->raid_disk = info->raid_disk;
  4630. else
  4631. rdev->raid_disk = -1;
  4632. if (rdev->raid_disk < mddev->raid_disks)
  4633. if (info->state & (1<<MD_DISK_SYNC))
  4634. set_bit(In_sync, &rdev->flags);
  4635. if (info->state & (1<<MD_DISK_WRITEMOSTLY))
  4636. set_bit(WriteMostly, &rdev->flags);
  4637. if (!mddev->persistent) {
  4638. printk(KERN_INFO "md: nonpersistent superblock ...\n");
  4639. rdev->sb_start = rdev->bdev->bd_inode->i_size / 512;
  4640. } else
  4641. rdev->sb_start = calc_dev_sboffset(rdev->bdev);
  4642. rdev->sectors = rdev->sb_start;
  4643. err = bind_rdev_to_array(rdev, mddev);
  4644. if (err) {
  4645. export_rdev(rdev);
  4646. return err;
  4647. }
  4648. }
  4649. return 0;
  4650. }
  4651. static int hot_remove_disk(mddev_t * mddev, dev_t dev)
  4652. {
  4653. char b[BDEVNAME_SIZE];
  4654. mdk_rdev_t *rdev;
  4655. rdev = find_rdev(mddev, dev);
  4656. if (!rdev)
  4657. return -ENXIO;
  4658. if (rdev->raid_disk >= 0)
  4659. goto busy;
  4660. kick_rdev_from_array(rdev);
  4661. md_update_sb(mddev, 1);
  4662. md_new_event(mddev);
  4663. return 0;
  4664. busy:
  4665. printk(KERN_WARNING "md: cannot remove active disk %s from %s ...\n",
  4666. bdevname(rdev->bdev,b), mdname(mddev));
  4667. return -EBUSY;
  4668. }
  4669. static int hot_add_disk(mddev_t * mddev, dev_t dev)
  4670. {
  4671. char b[BDEVNAME_SIZE];
  4672. int err;
  4673. mdk_rdev_t *rdev;
  4674. if (!mddev->pers)
  4675. return -ENODEV;
  4676. if (mddev->major_version != 0) {
  4677. printk(KERN_WARNING "%s: HOT_ADD may only be used with"
  4678. " version-0 superblocks.\n",
  4679. mdname(mddev));
  4680. return -EINVAL;
  4681. }
  4682. if (!mddev->pers->hot_add_disk) {
  4683. printk(KERN_WARNING
  4684. "%s: personality does not support diskops!\n",
  4685. mdname(mddev));
  4686. return -EINVAL;
  4687. }
  4688. rdev = md_import_device(dev, -1, 0);
  4689. if (IS_ERR(rdev)) {
  4690. printk(KERN_WARNING
  4691. "md: error, md_import_device() returned %ld\n",
  4692. PTR_ERR(rdev));
  4693. return -EINVAL;
  4694. }
  4695. if (mddev->persistent)
  4696. rdev->sb_start = calc_dev_sboffset(rdev->bdev);
  4697. else
  4698. rdev->sb_start = rdev->bdev->bd_inode->i_size / 512;
  4699. rdev->sectors = rdev->sb_start;
  4700. if (test_bit(Faulty, &rdev->flags)) {
  4701. printk(KERN_WARNING
  4702. "md: can not hot-add faulty %s disk to %s!\n",
  4703. bdevname(rdev->bdev,b), mdname(mddev));
  4704. err = -EINVAL;
  4705. goto abort_export;
  4706. }
  4707. clear_bit(In_sync, &rdev->flags);
  4708. rdev->desc_nr = -1;
  4709. rdev->saved_raid_disk = -1;
  4710. err = bind_rdev_to_array(rdev, mddev);
  4711. if (err)
  4712. goto abort_export;
  4713. /*
  4714. * The rest should better be atomic, we can have disk failures
  4715. * noticed in interrupt contexts ...
  4716. */
  4717. rdev->raid_disk = -1;
  4718. md_update_sb(mddev, 1);
  4719. /*
  4720. * Kick recovery, maybe this spare has to be added to the
  4721. * array immediately.
  4722. */
  4723. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  4724. md_wakeup_thread(mddev->thread);
  4725. md_new_event(mddev);
  4726. return 0;
  4727. abort_export:
  4728. export_rdev(rdev);
  4729. return err;
  4730. }
  4731. static int set_bitmap_file(mddev_t *mddev, int fd)
  4732. {
  4733. int err;
  4734. if (mddev->pers) {
  4735. if (!mddev->pers->quiesce)
  4736. return -EBUSY;
  4737. if (mddev->recovery || mddev->sync_thread)
  4738. return -EBUSY;
  4739. /* we should be able to change the bitmap.. */
  4740. }
  4741. if (fd >= 0) {
  4742. if (mddev->bitmap)
  4743. return -EEXIST; /* cannot add when bitmap is present */
  4744. mddev->bitmap_info.file = fget(fd);
  4745. if (mddev->bitmap_info.file == NULL) {
  4746. printk(KERN_ERR "%s: error: failed to get bitmap file\n",
  4747. mdname(mddev));
  4748. return -EBADF;
  4749. }
  4750. err = deny_bitmap_write_access(mddev->bitmap_info.file);
  4751. if (err) {
  4752. printk(KERN_ERR "%s: error: bitmap file is already in use\n",
  4753. mdname(mddev));
  4754. fput(mddev->bitmap_info.file);
  4755. mddev->bitmap_info.file = NULL;
  4756. return err;
  4757. }
  4758. mddev->bitmap_info.offset = 0; /* file overrides offset */
  4759. } else if (mddev->bitmap == NULL)
  4760. return -ENOENT; /* cannot remove what isn't there */
  4761. err = 0;
  4762. if (mddev->pers) {
  4763. mddev->pers->quiesce(mddev, 1);
  4764. if (fd >= 0) {
  4765. err = bitmap_create(mddev);
  4766. if (!err)
  4767. err = bitmap_load(mddev);
  4768. }
  4769. if (fd < 0 || err) {
  4770. bitmap_destroy(mddev);
  4771. fd = -1; /* make sure to put the file */
  4772. }
  4773. mddev->pers->quiesce(mddev, 0);
  4774. }
  4775. if (fd < 0) {
  4776. if (mddev->bitmap_info.file) {
  4777. restore_bitmap_write_access(mddev->bitmap_info.file);
  4778. fput(mddev->bitmap_info.file);
  4779. }
  4780. mddev->bitmap_info.file = NULL;
  4781. }
  4782. return err;
  4783. }
  4784. /*
  4785. * set_array_info is used two different ways
  4786. * The original usage is when creating a new array.
  4787. * In this usage, raid_disks is > 0 and it together with
  4788. * level, size, not_persistent,layout,chunksize determine the
  4789. * shape of the array.
  4790. * This will always create an array with a type-0.90.0 superblock.
  4791. * The newer usage is when assembling an array.
  4792. * In this case raid_disks will be 0, and the major_version field is
  4793. * use to determine which style super-blocks are to be found on the devices.
  4794. * The minor and patch _version numbers are also kept incase the
  4795. * super_block handler wishes to interpret them.
  4796. */
  4797. static int set_array_info(mddev_t * mddev, mdu_array_info_t *info)
  4798. {
  4799. if (info->raid_disks == 0) {
  4800. /* just setting version number for superblock loading */
  4801. if (info->major_version < 0 ||
  4802. info->major_version >= ARRAY_SIZE(super_types) ||
  4803. super_types[info->major_version].name == NULL) {
  4804. /* maybe try to auto-load a module? */
  4805. printk(KERN_INFO
  4806. "md: superblock version %d not known\n",
  4807. info->major_version);
  4808. return -EINVAL;
  4809. }
  4810. mddev->major_version = info->major_version;
  4811. mddev->minor_version = info->minor_version;
  4812. mddev->patch_version = info->patch_version;
  4813. mddev->persistent = !info->not_persistent;
  4814. /* ensure mddev_put doesn't delete this now that there
  4815. * is some minimal configuration.
  4816. */
  4817. mddev->ctime = get_seconds();
  4818. return 0;
  4819. }
  4820. mddev->major_version = MD_MAJOR_VERSION;
  4821. mddev->minor_version = MD_MINOR_VERSION;
  4822. mddev->patch_version = MD_PATCHLEVEL_VERSION;
  4823. mddev->ctime = get_seconds();
  4824. mddev->level = info->level;
  4825. mddev->clevel[0] = 0;
  4826. mddev->dev_sectors = 2 * (sector_t)info->size;
  4827. mddev->raid_disks = info->raid_disks;
  4828. /* don't set md_minor, it is determined by which /dev/md* was
  4829. * openned
  4830. */
  4831. if (info->state & (1<<MD_SB_CLEAN))
  4832. mddev->recovery_cp = MaxSector;
  4833. else
  4834. mddev->recovery_cp = 0;
  4835. mddev->persistent = ! info->not_persistent;
  4836. mddev->external = 0;
  4837. mddev->layout = info->layout;
  4838. mddev->chunk_sectors = info->chunk_size >> 9;
  4839. mddev->max_disks = MD_SB_DISKS;
  4840. if (mddev->persistent)
  4841. mddev->flags = 0;
  4842. set_bit(MD_CHANGE_DEVS, &mddev->flags);
  4843. mddev->bitmap_info.default_offset = MD_SB_BYTES >> 9;
  4844. mddev->bitmap_info.offset = 0;
  4845. mddev->reshape_position = MaxSector;
  4846. /*
  4847. * Generate a 128 bit UUID
  4848. */
  4849. get_random_bytes(mddev->uuid, 16);
  4850. mddev->new_level = mddev->level;
  4851. mddev->new_chunk_sectors = mddev->chunk_sectors;
  4852. mddev->new_layout = mddev->layout;
  4853. mddev->delta_disks = 0;
  4854. return 0;
  4855. }
  4856. void md_set_array_sectors(mddev_t *mddev, sector_t array_sectors)
  4857. {
  4858. WARN(!mddev_is_locked(mddev), "%s: unlocked mddev!\n", __func__);
  4859. if (mddev->external_size)
  4860. return;
  4861. mddev->array_sectors = array_sectors;
  4862. }
  4863. EXPORT_SYMBOL(md_set_array_sectors);
  4864. static int update_size(mddev_t *mddev, sector_t num_sectors)
  4865. {
  4866. mdk_rdev_t *rdev;
  4867. int rv;
  4868. int fit = (num_sectors == 0);
  4869. if (mddev->pers->resize == NULL)
  4870. return -EINVAL;
  4871. /* The "num_sectors" is the number of sectors of each device that
  4872. * is used. This can only make sense for arrays with redundancy.
  4873. * linear and raid0 always use whatever space is available. We can only
  4874. * consider changing this number if no resync or reconstruction is
  4875. * happening, and if the new size is acceptable. It must fit before the
  4876. * sb_start or, if that is <data_offset, it must fit before the size
  4877. * of each device. If num_sectors is zero, we find the largest size
  4878. * that fits.
  4879. */
  4880. if (mddev->sync_thread)
  4881. return -EBUSY;
  4882. if (mddev->bitmap)
  4883. /* Sorry, cannot grow a bitmap yet, just remove it,
  4884. * grow, and re-add.
  4885. */
  4886. return -EBUSY;
  4887. list_for_each_entry(rdev, &mddev->disks, same_set) {
  4888. sector_t avail = rdev->sectors;
  4889. if (fit && (num_sectors == 0 || num_sectors > avail))
  4890. num_sectors = avail;
  4891. if (avail < num_sectors)
  4892. return -ENOSPC;
  4893. }
  4894. rv = mddev->pers->resize(mddev, num_sectors);
  4895. if (!rv)
  4896. revalidate_disk(mddev->gendisk);
  4897. return rv;
  4898. }
  4899. static int update_raid_disks(mddev_t *mddev, int raid_disks)
  4900. {
  4901. int rv;
  4902. /* change the number of raid disks */
  4903. if (mddev->pers->check_reshape == NULL)
  4904. return -EINVAL;
  4905. if (raid_disks <= 0 ||
  4906. (mddev->max_disks && raid_disks >= mddev->max_disks))
  4907. return -EINVAL;
  4908. if (mddev->sync_thread || mddev->reshape_position != MaxSector)
  4909. return -EBUSY;
  4910. mddev->delta_disks = raid_disks - mddev->raid_disks;
  4911. rv = mddev->pers->check_reshape(mddev);
  4912. return rv;
  4913. }
  4914. /*
  4915. * update_array_info is used to change the configuration of an
  4916. * on-line array.
  4917. * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
  4918. * fields in the info are checked against the array.
  4919. * Any differences that cannot be handled will cause an error.
  4920. * Normally, only one change can be managed at a time.
  4921. */
  4922. static int update_array_info(mddev_t *mddev, mdu_array_info_t *info)
  4923. {
  4924. int rv = 0;
  4925. int cnt = 0;
  4926. int state = 0;
  4927. /* calculate expected state,ignoring low bits */
  4928. if (mddev->bitmap && mddev->bitmap_info.offset)
  4929. state |= (1 << MD_SB_BITMAP_PRESENT);
  4930. if (mddev->major_version != info->major_version ||
  4931. mddev->minor_version != info->minor_version ||
  4932. /* mddev->patch_version != info->patch_version || */
  4933. mddev->ctime != info->ctime ||
  4934. mddev->level != info->level ||
  4935. /* mddev->layout != info->layout || */
  4936. !mddev->persistent != info->not_persistent||
  4937. mddev->chunk_sectors != info->chunk_size >> 9 ||
  4938. /* ignore bottom 8 bits of state, and allow SB_BITMAP_PRESENT to change */
  4939. ((state^info->state) & 0xfffffe00)
  4940. )
  4941. return -EINVAL;
  4942. /* Check there is only one change */
  4943. if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
  4944. cnt++;
  4945. if (mddev->raid_disks != info->raid_disks)
  4946. cnt++;
  4947. if (mddev->layout != info->layout)
  4948. cnt++;
  4949. if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT))
  4950. cnt++;
  4951. if (cnt == 0)
  4952. return 0;
  4953. if (cnt > 1)
  4954. return -EINVAL;
  4955. if (mddev->layout != info->layout) {
  4956. /* Change layout
  4957. * we don't need to do anything at the md level, the
  4958. * personality will take care of it all.
  4959. */
  4960. if (mddev->pers->check_reshape == NULL)
  4961. return -EINVAL;
  4962. else {
  4963. mddev->new_layout = info->layout;
  4964. rv = mddev->pers->check_reshape(mddev);
  4965. if (rv)
  4966. mddev->new_layout = mddev->layout;
  4967. return rv;
  4968. }
  4969. }
  4970. if (info->size >= 0 && mddev->dev_sectors / 2 != info->size)
  4971. rv = update_size(mddev, (sector_t)info->size * 2);
  4972. if (mddev->raid_disks != info->raid_disks)
  4973. rv = update_raid_disks(mddev, info->raid_disks);
  4974. if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) {
  4975. if (mddev->pers->quiesce == NULL)
  4976. return -EINVAL;
  4977. if (mddev->recovery || mddev->sync_thread)
  4978. return -EBUSY;
  4979. if (info->state & (1<<MD_SB_BITMAP_PRESENT)) {
  4980. /* add the bitmap */
  4981. if (mddev->bitmap)
  4982. return -EEXIST;
  4983. if (mddev->bitmap_info.default_offset == 0)
  4984. return -EINVAL;
  4985. mddev->bitmap_info.offset =
  4986. mddev->bitmap_info.default_offset;
  4987. mddev->pers->quiesce(mddev, 1);
  4988. rv = bitmap_create(mddev);
  4989. if (!rv)
  4990. rv = bitmap_load(mddev);
  4991. if (rv)
  4992. bitmap_destroy(mddev);
  4993. mddev->pers->quiesce(mddev, 0);
  4994. } else {
  4995. /* remove the bitmap */
  4996. if (!mddev->bitmap)
  4997. return -ENOENT;
  4998. if (mddev->bitmap->file)
  4999. return -EINVAL;
  5000. mddev->pers->quiesce(mddev, 1);
  5001. bitmap_destroy(mddev);
  5002. mddev->pers->quiesce(mddev, 0);
  5003. mddev->bitmap_info.offset = 0;
  5004. }
  5005. }
  5006. md_update_sb(mddev, 1);
  5007. return rv;
  5008. }
  5009. static int set_disk_faulty(mddev_t *mddev, dev_t dev)
  5010. {
  5011. mdk_rdev_t *rdev;
  5012. if (mddev->pers == NULL)
  5013. return -ENODEV;
  5014. rdev = find_rdev(mddev, dev);
  5015. if (!rdev)
  5016. return -ENODEV;
  5017. md_error(mddev, rdev);
  5018. return 0;
  5019. }
  5020. /*
  5021. * We have a problem here : there is no easy way to give a CHS
  5022. * virtual geometry. We currently pretend that we have a 2 heads
  5023. * 4 sectors (with a BIG number of cylinders...). This drives
  5024. * dosfs just mad... ;-)
  5025. */
  5026. static int md_getgeo(struct block_device *bdev, struct hd_geometry *geo)
  5027. {
  5028. mddev_t *mddev = bdev->bd_disk->private_data;
  5029. geo->heads = 2;
  5030. geo->sectors = 4;
  5031. geo->cylinders = mddev->array_sectors / 8;
  5032. return 0;
  5033. }
  5034. static int md_ioctl(struct block_device *bdev, fmode_t mode,
  5035. unsigned int cmd, unsigned long arg)
  5036. {
  5037. int err = 0;
  5038. void __user *argp = (void __user *)arg;
  5039. mddev_t *mddev = NULL;
  5040. int ro;
  5041. if (!capable(CAP_SYS_ADMIN))
  5042. return -EACCES;
  5043. /*
  5044. * Commands dealing with the RAID driver but not any
  5045. * particular array:
  5046. */
  5047. switch (cmd)
  5048. {
  5049. case RAID_VERSION:
  5050. err = get_version(argp);
  5051. goto done;
  5052. case PRINT_RAID_DEBUG:
  5053. err = 0;
  5054. md_print_devices();
  5055. goto done;
  5056. #ifndef MODULE
  5057. case RAID_AUTORUN:
  5058. err = 0;
  5059. autostart_arrays(arg);
  5060. goto done;
  5061. #endif
  5062. default:;
  5063. }
  5064. /*
  5065. * Commands creating/starting a new array:
  5066. */
  5067. mddev = bdev->bd_disk->private_data;
  5068. if (!mddev) {
  5069. BUG();
  5070. goto abort;
  5071. }
  5072. err = mddev_lock(mddev);
  5073. if (err) {
  5074. printk(KERN_INFO
  5075. "md: ioctl lock interrupted, reason %d, cmd %d\n",
  5076. err, cmd);
  5077. goto abort;
  5078. }
  5079. switch (cmd)
  5080. {
  5081. case SET_ARRAY_INFO:
  5082. {
  5083. mdu_array_info_t info;
  5084. if (!arg)
  5085. memset(&info, 0, sizeof(info));
  5086. else if (copy_from_user(&info, argp, sizeof(info))) {
  5087. err = -EFAULT;
  5088. goto abort_unlock;
  5089. }
  5090. if (mddev->pers) {
  5091. err = update_array_info(mddev, &info);
  5092. if (err) {
  5093. printk(KERN_WARNING "md: couldn't update"
  5094. " array info. %d\n", err);
  5095. goto abort_unlock;
  5096. }
  5097. goto done_unlock;
  5098. }
  5099. if (!list_empty(&mddev->disks)) {
  5100. printk(KERN_WARNING
  5101. "md: array %s already has disks!\n",
  5102. mdname(mddev));
  5103. err = -EBUSY;
  5104. goto abort_unlock;
  5105. }
  5106. if (mddev->raid_disks) {
  5107. printk(KERN_WARNING
  5108. "md: array %s already initialised!\n",
  5109. mdname(mddev));
  5110. err = -EBUSY;
  5111. goto abort_unlock;
  5112. }
  5113. err = set_array_info(mddev, &info);
  5114. if (err) {
  5115. printk(KERN_WARNING "md: couldn't set"
  5116. " array info. %d\n", err);
  5117. goto abort_unlock;
  5118. }
  5119. }
  5120. goto done_unlock;
  5121. default:;
  5122. }
  5123. /*
  5124. * Commands querying/configuring an existing array:
  5125. */
  5126. /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
  5127. * RUN_ARRAY, and GET_ and SET_BITMAP_FILE are allowed */
  5128. if ((!mddev->raid_disks && !mddev->external)
  5129. && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
  5130. && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE
  5131. && cmd != GET_BITMAP_FILE) {
  5132. err = -ENODEV;
  5133. goto abort_unlock;
  5134. }
  5135. /*
  5136. * Commands even a read-only array can execute:
  5137. */
  5138. switch (cmd)
  5139. {
  5140. case GET_ARRAY_INFO:
  5141. err = get_array_info(mddev, argp);
  5142. goto done_unlock;
  5143. case GET_BITMAP_FILE:
  5144. err = get_bitmap_file(mddev, argp);
  5145. goto done_unlock;
  5146. case GET_DISK_INFO:
  5147. err = get_disk_info(mddev, argp);
  5148. goto done_unlock;
  5149. case RESTART_ARRAY_RW:
  5150. err = restart_array(mddev);
  5151. goto done_unlock;
  5152. case STOP_ARRAY:
  5153. err = do_md_stop(mddev, 0, 1);
  5154. goto done_unlock;
  5155. case STOP_ARRAY_RO:
  5156. err = md_set_readonly(mddev, 1);
  5157. goto done_unlock;
  5158. case BLKROSET:
  5159. if (get_user(ro, (int __user *)(arg))) {
  5160. err = -EFAULT;
  5161. goto done_unlock;
  5162. }
  5163. err = -EINVAL;
  5164. /* if the bdev is going readonly the value of mddev->ro
  5165. * does not matter, no writes are coming
  5166. */
  5167. if (ro)
  5168. goto done_unlock;
  5169. /* are we are already prepared for writes? */
  5170. if (mddev->ro != 1)
  5171. goto done_unlock;
  5172. /* transitioning to readauto need only happen for
  5173. * arrays that call md_write_start
  5174. */
  5175. if (mddev->pers) {
  5176. err = restart_array(mddev);
  5177. if (err == 0) {
  5178. mddev->ro = 2;
  5179. set_disk_ro(mddev->gendisk, 0);
  5180. }
  5181. }
  5182. goto done_unlock;
  5183. }
  5184. /*
  5185. * The remaining ioctls are changing the state of the
  5186. * superblock, so we do not allow them on read-only arrays.
  5187. * However non-MD ioctls (e.g. get-size) will still come through
  5188. * here and hit the 'default' below, so only disallow
  5189. * 'md' ioctls, and switch to rw mode if started auto-readonly.
  5190. */
  5191. if (_IOC_TYPE(cmd) == MD_MAJOR && mddev->ro && mddev->pers) {
  5192. if (mddev->ro == 2) {
  5193. mddev->ro = 0;
  5194. sysfs_notify_dirent_safe(mddev->sysfs_state);
  5195. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  5196. md_wakeup_thread(mddev->thread);
  5197. } else {
  5198. err = -EROFS;
  5199. goto abort_unlock;
  5200. }
  5201. }
  5202. switch (cmd)
  5203. {
  5204. case ADD_NEW_DISK:
  5205. {
  5206. mdu_disk_info_t info;
  5207. if (copy_from_user(&info, argp, sizeof(info)))
  5208. err = -EFAULT;
  5209. else
  5210. err = add_new_disk(mddev, &info);
  5211. goto done_unlock;
  5212. }
  5213. case HOT_REMOVE_DISK:
  5214. err = hot_remove_disk(mddev, new_decode_dev(arg));
  5215. goto done_unlock;
  5216. case HOT_ADD_DISK:
  5217. err = hot_add_disk(mddev, new_decode_dev(arg));
  5218. goto done_unlock;
  5219. case SET_DISK_FAULTY:
  5220. err = set_disk_faulty(mddev, new_decode_dev(arg));
  5221. goto done_unlock;
  5222. case RUN_ARRAY:
  5223. err = do_md_run(mddev);
  5224. goto done_unlock;
  5225. case SET_BITMAP_FILE:
  5226. err = set_bitmap_file(mddev, (int)arg);
  5227. goto done_unlock;
  5228. default:
  5229. err = -EINVAL;
  5230. goto abort_unlock;
  5231. }
  5232. done_unlock:
  5233. abort_unlock:
  5234. if (mddev->hold_active == UNTIL_IOCTL &&
  5235. err != -EINVAL)
  5236. mddev->hold_active = 0;
  5237. mddev_unlock(mddev);
  5238. return err;
  5239. done:
  5240. if (err)
  5241. MD_BUG();
  5242. abort:
  5243. return err;
  5244. }
  5245. #ifdef CONFIG_COMPAT
  5246. static int md_compat_ioctl(struct block_device *bdev, fmode_t mode,
  5247. unsigned int cmd, unsigned long arg)
  5248. {
  5249. switch (cmd) {
  5250. case HOT_REMOVE_DISK:
  5251. case HOT_ADD_DISK:
  5252. case SET_DISK_FAULTY:
  5253. case SET_BITMAP_FILE:
  5254. /* These take in integer arg, do not convert */
  5255. break;
  5256. default:
  5257. arg = (unsigned long)compat_ptr(arg);
  5258. break;
  5259. }
  5260. return md_ioctl(bdev, mode, cmd, arg);
  5261. }
  5262. #endif /* CONFIG_COMPAT */
  5263. static int md_open(struct block_device *bdev, fmode_t mode)
  5264. {
  5265. /*
  5266. * Succeed if we can lock the mddev, which confirms that
  5267. * it isn't being stopped right now.
  5268. */
  5269. mddev_t *mddev = mddev_find(bdev->bd_dev);
  5270. int err;
  5271. lock_kernel();
  5272. if (mddev->gendisk != bdev->bd_disk) {
  5273. /* we are racing with mddev_put which is discarding this
  5274. * bd_disk.
  5275. */
  5276. mddev_put(mddev);
  5277. /* Wait until bdev->bd_disk is definitely gone */
  5278. flush_scheduled_work();
  5279. /* Then retry the open from the top */
  5280. unlock_kernel();
  5281. return -ERESTARTSYS;
  5282. }
  5283. BUG_ON(mddev != bdev->bd_disk->private_data);
  5284. if ((err = mutex_lock_interruptible(&mddev->open_mutex)))
  5285. goto out;
  5286. err = 0;
  5287. atomic_inc(&mddev->openers);
  5288. mutex_unlock(&mddev->open_mutex);
  5289. check_disk_size_change(mddev->gendisk, bdev);
  5290. out:
  5291. unlock_kernel();
  5292. return err;
  5293. }
  5294. static int md_release(struct gendisk *disk, fmode_t mode)
  5295. {
  5296. mddev_t *mddev = disk->private_data;
  5297. BUG_ON(!mddev);
  5298. lock_kernel();
  5299. atomic_dec(&mddev->openers);
  5300. mddev_put(mddev);
  5301. unlock_kernel();
  5302. return 0;
  5303. }
  5304. static const struct block_device_operations md_fops =
  5305. {
  5306. .owner = THIS_MODULE,
  5307. .open = md_open,
  5308. .release = md_release,
  5309. .ioctl = md_ioctl,
  5310. #ifdef CONFIG_COMPAT
  5311. .compat_ioctl = md_compat_ioctl,
  5312. #endif
  5313. .getgeo = md_getgeo,
  5314. };
  5315. static int md_thread(void * arg)
  5316. {
  5317. mdk_thread_t *thread = arg;
  5318. /*
  5319. * md_thread is a 'system-thread', it's priority should be very
  5320. * high. We avoid resource deadlocks individually in each
  5321. * raid personality. (RAID5 does preallocation) We also use RR and
  5322. * the very same RT priority as kswapd, thus we will never get
  5323. * into a priority inversion deadlock.
  5324. *
  5325. * we definitely have to have equal or higher priority than
  5326. * bdflush, otherwise bdflush will deadlock if there are too
  5327. * many dirty RAID5 blocks.
  5328. */
  5329. allow_signal(SIGKILL);
  5330. while (!kthread_should_stop()) {
  5331. /* We need to wait INTERRUPTIBLE so that
  5332. * we don't add to the load-average.
  5333. * That means we need to be sure no signals are
  5334. * pending
  5335. */
  5336. if (signal_pending(current))
  5337. flush_signals(current);
  5338. wait_event_interruptible_timeout
  5339. (thread->wqueue,
  5340. test_bit(THREAD_WAKEUP, &thread->flags)
  5341. || kthread_should_stop(),
  5342. thread->timeout);
  5343. clear_bit(THREAD_WAKEUP, &thread->flags);
  5344. thread->run(thread->mddev);
  5345. }
  5346. return 0;
  5347. }
  5348. void md_wakeup_thread(mdk_thread_t *thread)
  5349. {
  5350. if (thread) {
  5351. dprintk("md: waking up MD thread %s.\n", thread->tsk->comm);
  5352. set_bit(THREAD_WAKEUP, &thread->flags);
  5353. wake_up(&thread->wqueue);
  5354. }
  5355. }
  5356. mdk_thread_t *md_register_thread(void (*run) (mddev_t *), mddev_t *mddev,
  5357. const char *name)
  5358. {
  5359. mdk_thread_t *thread;
  5360. thread = kzalloc(sizeof(mdk_thread_t), GFP_KERNEL);
  5361. if (!thread)
  5362. return NULL;
  5363. init_waitqueue_head(&thread->wqueue);
  5364. thread->run = run;
  5365. thread->mddev = mddev;
  5366. thread->timeout = MAX_SCHEDULE_TIMEOUT;
  5367. thread->tsk = kthread_run(md_thread, thread,
  5368. "%s_%s",
  5369. mdname(thread->mddev),
  5370. name ?: mddev->pers->name);
  5371. if (IS_ERR(thread->tsk)) {
  5372. kfree(thread);
  5373. return NULL;
  5374. }
  5375. return thread;
  5376. }
  5377. void md_unregister_thread(mdk_thread_t *thread)
  5378. {
  5379. if (!thread)
  5380. return;
  5381. dprintk("interrupting MD-thread pid %d\n", task_pid_nr(thread->tsk));
  5382. kthread_stop(thread->tsk);
  5383. kfree(thread);
  5384. }
  5385. void md_error(mddev_t *mddev, mdk_rdev_t *rdev)
  5386. {
  5387. if (!mddev) {
  5388. MD_BUG();
  5389. return;
  5390. }
  5391. if (!rdev || test_bit(Faulty, &rdev->flags))
  5392. return;
  5393. if (mddev->external)
  5394. set_bit(Blocked, &rdev->flags);
  5395. /*
  5396. dprintk("md_error dev:%s, rdev:(%d:%d), (caller: %p,%p,%p,%p).\n",
  5397. mdname(mddev),
  5398. MAJOR(rdev->bdev->bd_dev), MINOR(rdev->bdev->bd_dev),
  5399. __builtin_return_address(0),__builtin_return_address(1),
  5400. __builtin_return_address(2),__builtin_return_address(3));
  5401. */
  5402. if (!mddev->pers)
  5403. return;
  5404. if (!mddev->pers->error_handler)
  5405. return;
  5406. mddev->pers->error_handler(mddev,rdev);
  5407. if (mddev->degraded)
  5408. set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
  5409. sysfs_notify_dirent_safe(rdev->sysfs_state);
  5410. set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  5411. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  5412. md_wakeup_thread(mddev->thread);
  5413. if (mddev->event_work.func)
  5414. schedule_work(&mddev->event_work);
  5415. md_new_event_inintr(mddev);
  5416. }
  5417. /* seq_file implementation /proc/mdstat */
  5418. static void status_unused(struct seq_file *seq)
  5419. {
  5420. int i = 0;
  5421. mdk_rdev_t *rdev;
  5422. seq_printf(seq, "unused devices: ");
  5423. list_for_each_entry(rdev, &pending_raid_disks, same_set) {
  5424. char b[BDEVNAME_SIZE];
  5425. i++;
  5426. seq_printf(seq, "%s ",
  5427. bdevname(rdev->bdev,b));
  5428. }
  5429. if (!i)
  5430. seq_printf(seq, "<none>");
  5431. seq_printf(seq, "\n");
  5432. }
  5433. static void status_resync(struct seq_file *seq, mddev_t * mddev)
  5434. {
  5435. sector_t max_sectors, resync, res;
  5436. unsigned long dt, db;
  5437. sector_t rt;
  5438. int scale;
  5439. unsigned int per_milli;
  5440. resync = mddev->curr_resync - atomic_read(&mddev->recovery_active);
  5441. if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
  5442. max_sectors = mddev->resync_max_sectors;
  5443. else
  5444. max_sectors = mddev->dev_sectors;
  5445. /*
  5446. * Should not happen.
  5447. */
  5448. if (!max_sectors) {
  5449. MD_BUG();
  5450. return;
  5451. }
  5452. /* Pick 'scale' such that (resync>>scale)*1000 will fit
  5453. * in a sector_t, and (max_sectors>>scale) will fit in a
  5454. * u32, as those are the requirements for sector_div.
  5455. * Thus 'scale' must be at least 10
  5456. */
  5457. scale = 10;
  5458. if (sizeof(sector_t) > sizeof(unsigned long)) {
  5459. while ( max_sectors/2 > (1ULL<<(scale+32)))
  5460. scale++;
  5461. }
  5462. res = (resync>>scale)*1000;
  5463. sector_div(res, (u32)((max_sectors>>scale)+1));
  5464. per_milli = res;
  5465. {
  5466. int i, x = per_milli/50, y = 20-x;
  5467. seq_printf(seq, "[");
  5468. for (i = 0; i < x; i++)
  5469. seq_printf(seq, "=");
  5470. seq_printf(seq, ">");
  5471. for (i = 0; i < y; i++)
  5472. seq_printf(seq, ".");
  5473. seq_printf(seq, "] ");
  5474. }
  5475. seq_printf(seq, " %s =%3u.%u%% (%llu/%llu)",
  5476. (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery)?
  5477. "reshape" :
  5478. (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)?
  5479. "check" :
  5480. (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
  5481. "resync" : "recovery"))),
  5482. per_milli/10, per_milli % 10,
  5483. (unsigned long long) resync/2,
  5484. (unsigned long long) max_sectors/2);
  5485. /*
  5486. * dt: time from mark until now
  5487. * db: blocks written from mark until now
  5488. * rt: remaining time
  5489. *
  5490. * rt is a sector_t, so could be 32bit or 64bit.
  5491. * So we divide before multiply in case it is 32bit and close
  5492. * to the limit.
  5493. * We scale the divisor (db) by 32 to avoid loosing precision
  5494. * near the end of resync when the number of remaining sectors
  5495. * is close to 'db'.
  5496. * We then divide rt by 32 after multiplying by db to compensate.
  5497. * The '+1' avoids division by zero if db is very small.
  5498. */
  5499. dt = ((jiffies - mddev->resync_mark) / HZ);
  5500. if (!dt) dt++;
  5501. db = (mddev->curr_mark_cnt - atomic_read(&mddev->recovery_active))
  5502. - mddev->resync_mark_cnt;
  5503. rt = max_sectors - resync; /* number of remaining sectors */
  5504. sector_div(rt, db/32+1);
  5505. rt *= dt;
  5506. rt >>= 5;
  5507. seq_printf(seq, " finish=%lu.%lumin", (unsigned long)rt / 60,
  5508. ((unsigned long)rt % 60)/6);
  5509. seq_printf(seq, " speed=%ldK/sec", db/2/dt);
  5510. }
  5511. static void *md_seq_start(struct seq_file *seq, loff_t *pos)
  5512. {
  5513. struct list_head *tmp;
  5514. loff_t l = *pos;
  5515. mddev_t *mddev;
  5516. if (l >= 0x10000)
  5517. return NULL;
  5518. if (!l--)
  5519. /* header */
  5520. return (void*)1;
  5521. spin_lock(&all_mddevs_lock);
  5522. list_for_each(tmp,&all_mddevs)
  5523. if (!l--) {
  5524. mddev = list_entry(tmp, mddev_t, all_mddevs);
  5525. mddev_get(mddev);
  5526. spin_unlock(&all_mddevs_lock);
  5527. return mddev;
  5528. }
  5529. spin_unlock(&all_mddevs_lock);
  5530. if (!l--)
  5531. return (void*)2;/* tail */
  5532. return NULL;
  5533. }
  5534. static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  5535. {
  5536. struct list_head *tmp;
  5537. mddev_t *next_mddev, *mddev = v;
  5538. ++*pos;
  5539. if (v == (void*)2)
  5540. return NULL;
  5541. spin_lock(&all_mddevs_lock);
  5542. if (v == (void*)1)
  5543. tmp = all_mddevs.next;
  5544. else
  5545. tmp = mddev->all_mddevs.next;
  5546. if (tmp != &all_mddevs)
  5547. next_mddev = mddev_get(list_entry(tmp,mddev_t,all_mddevs));
  5548. else {
  5549. next_mddev = (void*)2;
  5550. *pos = 0x10000;
  5551. }
  5552. spin_unlock(&all_mddevs_lock);
  5553. if (v != (void*)1)
  5554. mddev_put(mddev);
  5555. return next_mddev;
  5556. }
  5557. static void md_seq_stop(struct seq_file *seq, void *v)
  5558. {
  5559. mddev_t *mddev = v;
  5560. if (mddev && v != (void*)1 && v != (void*)2)
  5561. mddev_put(mddev);
  5562. }
  5563. struct mdstat_info {
  5564. int event;
  5565. };
  5566. static int md_seq_show(struct seq_file *seq, void *v)
  5567. {
  5568. mddev_t *mddev = v;
  5569. sector_t sectors;
  5570. mdk_rdev_t *rdev;
  5571. struct mdstat_info *mi = seq->private;
  5572. struct bitmap *bitmap;
  5573. if (v == (void*)1) {
  5574. struct mdk_personality *pers;
  5575. seq_printf(seq, "Personalities : ");
  5576. spin_lock(&pers_lock);
  5577. list_for_each_entry(pers, &pers_list, list)
  5578. seq_printf(seq, "[%s] ", pers->name);
  5579. spin_unlock(&pers_lock);
  5580. seq_printf(seq, "\n");
  5581. mi->event = atomic_read(&md_event_count);
  5582. return 0;
  5583. }
  5584. if (v == (void*)2) {
  5585. status_unused(seq);
  5586. return 0;
  5587. }
  5588. if (mddev_lock(mddev) < 0)
  5589. return -EINTR;
  5590. if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
  5591. seq_printf(seq, "%s : %sactive", mdname(mddev),
  5592. mddev->pers ? "" : "in");
  5593. if (mddev->pers) {
  5594. if (mddev->ro==1)
  5595. seq_printf(seq, " (read-only)");
  5596. if (mddev->ro==2)
  5597. seq_printf(seq, " (auto-read-only)");
  5598. seq_printf(seq, " %s", mddev->pers->name);
  5599. }
  5600. sectors = 0;
  5601. list_for_each_entry(rdev, &mddev->disks, same_set) {
  5602. char b[BDEVNAME_SIZE];
  5603. seq_printf(seq, " %s[%d]",
  5604. bdevname(rdev->bdev,b), rdev->desc_nr);
  5605. if (test_bit(WriteMostly, &rdev->flags))
  5606. seq_printf(seq, "(W)");
  5607. if (test_bit(Faulty, &rdev->flags)) {
  5608. seq_printf(seq, "(F)");
  5609. continue;
  5610. } else if (rdev->raid_disk < 0)
  5611. seq_printf(seq, "(S)"); /* spare */
  5612. sectors += rdev->sectors;
  5613. }
  5614. if (!list_empty(&mddev->disks)) {
  5615. if (mddev->pers)
  5616. seq_printf(seq, "\n %llu blocks",
  5617. (unsigned long long)
  5618. mddev->array_sectors / 2);
  5619. else
  5620. seq_printf(seq, "\n %llu blocks",
  5621. (unsigned long long)sectors / 2);
  5622. }
  5623. if (mddev->persistent) {
  5624. if (mddev->major_version != 0 ||
  5625. mddev->minor_version != 90) {
  5626. seq_printf(seq," super %d.%d",
  5627. mddev->major_version,
  5628. mddev->minor_version);
  5629. }
  5630. } else if (mddev->external)
  5631. seq_printf(seq, " super external:%s",
  5632. mddev->metadata_type);
  5633. else
  5634. seq_printf(seq, " super non-persistent");
  5635. if (mddev->pers) {
  5636. mddev->pers->status(seq, mddev);
  5637. seq_printf(seq, "\n ");
  5638. if (mddev->pers->sync_request) {
  5639. if (mddev->curr_resync > 2) {
  5640. status_resync(seq, mddev);
  5641. seq_printf(seq, "\n ");
  5642. } else if (mddev->curr_resync == 1 || mddev->curr_resync == 2)
  5643. seq_printf(seq, "\tresync=DELAYED\n ");
  5644. else if (mddev->recovery_cp < MaxSector)
  5645. seq_printf(seq, "\tresync=PENDING\n ");
  5646. }
  5647. } else
  5648. seq_printf(seq, "\n ");
  5649. if ((bitmap = mddev->bitmap)) {
  5650. unsigned long chunk_kb;
  5651. unsigned long flags;
  5652. spin_lock_irqsave(&bitmap->lock, flags);
  5653. chunk_kb = mddev->bitmap_info.chunksize >> 10;
  5654. seq_printf(seq, "bitmap: %lu/%lu pages [%luKB], "
  5655. "%lu%s chunk",
  5656. bitmap->pages - bitmap->missing_pages,
  5657. bitmap->pages,
  5658. (bitmap->pages - bitmap->missing_pages)
  5659. << (PAGE_SHIFT - 10),
  5660. chunk_kb ? chunk_kb : mddev->bitmap_info.chunksize,
  5661. chunk_kb ? "KB" : "B");
  5662. if (bitmap->file) {
  5663. seq_printf(seq, ", file: ");
  5664. seq_path(seq, &bitmap->file->f_path, " \t\n");
  5665. }
  5666. seq_printf(seq, "\n");
  5667. spin_unlock_irqrestore(&bitmap->lock, flags);
  5668. }
  5669. seq_printf(seq, "\n");
  5670. }
  5671. mddev_unlock(mddev);
  5672. return 0;
  5673. }
  5674. static const struct seq_operations md_seq_ops = {
  5675. .start = md_seq_start,
  5676. .next = md_seq_next,
  5677. .stop = md_seq_stop,
  5678. .show = md_seq_show,
  5679. };
  5680. static int md_seq_open(struct inode *inode, struct file *file)
  5681. {
  5682. int error;
  5683. struct mdstat_info *mi = kmalloc(sizeof(*mi), GFP_KERNEL);
  5684. if (mi == NULL)
  5685. return -ENOMEM;
  5686. error = seq_open(file, &md_seq_ops);
  5687. if (error)
  5688. kfree(mi);
  5689. else {
  5690. struct seq_file *p = file->private_data;
  5691. p->private = mi;
  5692. mi->event = atomic_read(&md_event_count);
  5693. }
  5694. return error;
  5695. }
  5696. static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
  5697. {
  5698. struct seq_file *m = filp->private_data;
  5699. struct mdstat_info *mi = m->private;
  5700. int mask;
  5701. poll_wait(filp, &md_event_waiters, wait);
  5702. /* always allow read */
  5703. mask = POLLIN | POLLRDNORM;
  5704. if (mi->event != atomic_read(&md_event_count))
  5705. mask |= POLLERR | POLLPRI;
  5706. return mask;
  5707. }
  5708. static const struct file_operations md_seq_fops = {
  5709. .owner = THIS_MODULE,
  5710. .open = md_seq_open,
  5711. .read = seq_read,
  5712. .llseek = seq_lseek,
  5713. .release = seq_release_private,
  5714. .poll = mdstat_poll,
  5715. };
  5716. int register_md_personality(struct mdk_personality *p)
  5717. {
  5718. spin_lock(&pers_lock);
  5719. list_add_tail(&p->list, &pers_list);
  5720. printk(KERN_INFO "md: %s personality registered for level %d\n", p->name, p->level);
  5721. spin_unlock(&pers_lock);
  5722. return 0;
  5723. }
  5724. int unregister_md_personality(struct mdk_personality *p)
  5725. {
  5726. printk(KERN_INFO "md: %s personality unregistered\n", p->name);
  5727. spin_lock(&pers_lock);
  5728. list_del_init(&p->list);
  5729. spin_unlock(&pers_lock);
  5730. return 0;
  5731. }
  5732. static int is_mddev_idle(mddev_t *mddev, int init)
  5733. {
  5734. mdk_rdev_t * rdev;
  5735. int idle;
  5736. int curr_events;
  5737. idle = 1;
  5738. rcu_read_lock();
  5739. rdev_for_each_rcu(rdev, mddev) {
  5740. struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
  5741. curr_events = (int)part_stat_read(&disk->part0, sectors[0]) +
  5742. (int)part_stat_read(&disk->part0, sectors[1]) -
  5743. atomic_read(&disk->sync_io);
  5744. /* sync IO will cause sync_io to increase before the disk_stats
  5745. * as sync_io is counted when a request starts, and
  5746. * disk_stats is counted when it completes.
  5747. * So resync activity will cause curr_events to be smaller than
  5748. * when there was no such activity.
  5749. * non-sync IO will cause disk_stat to increase without
  5750. * increasing sync_io so curr_events will (eventually)
  5751. * be larger than it was before. Once it becomes
  5752. * substantially larger, the test below will cause
  5753. * the array to appear non-idle, and resync will slow
  5754. * down.
  5755. * If there is a lot of outstanding resync activity when
  5756. * we set last_event to curr_events, then all that activity
  5757. * completing might cause the array to appear non-idle
  5758. * and resync will be slowed down even though there might
  5759. * not have been non-resync activity. This will only
  5760. * happen once though. 'last_events' will soon reflect
  5761. * the state where there is little or no outstanding
  5762. * resync requests, and further resync activity will
  5763. * always make curr_events less than last_events.
  5764. *
  5765. */
  5766. if (init || curr_events - rdev->last_events > 64) {
  5767. rdev->last_events = curr_events;
  5768. idle = 0;
  5769. }
  5770. }
  5771. rcu_read_unlock();
  5772. return idle;
  5773. }
  5774. void md_done_sync(mddev_t *mddev, int blocks, int ok)
  5775. {
  5776. /* another "blocks" (512byte) blocks have been synced */
  5777. atomic_sub(blocks, &mddev->recovery_active);
  5778. wake_up(&mddev->recovery_wait);
  5779. if (!ok) {
  5780. set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  5781. md_wakeup_thread(mddev->thread);
  5782. // stop recovery, signal do_sync ....
  5783. }
  5784. }
  5785. /* md_write_start(mddev, bi)
  5786. * If we need to update some array metadata (e.g. 'active' flag
  5787. * in superblock) before writing, schedule a superblock update
  5788. * and wait for it to complete.
  5789. */
  5790. void md_write_start(mddev_t *mddev, struct bio *bi)
  5791. {
  5792. int did_change = 0;
  5793. if (bio_data_dir(bi) != WRITE)
  5794. return;
  5795. BUG_ON(mddev->ro == 1);
  5796. if (mddev->ro == 2) {
  5797. /* need to switch to read/write */
  5798. mddev->ro = 0;
  5799. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  5800. md_wakeup_thread(mddev->thread);
  5801. md_wakeup_thread(mddev->sync_thread);
  5802. did_change = 1;
  5803. }
  5804. atomic_inc(&mddev->writes_pending);
  5805. if (mddev->safemode == 1)
  5806. mddev->safemode = 0;
  5807. if (mddev->in_sync) {
  5808. spin_lock_irq(&mddev->write_lock);
  5809. if (mddev->in_sync) {
  5810. mddev->in_sync = 0;
  5811. set_bit(MD_CHANGE_CLEAN, &mddev->flags);
  5812. set_bit(MD_CHANGE_PENDING, &mddev->flags);
  5813. md_wakeup_thread(mddev->thread);
  5814. did_change = 1;
  5815. }
  5816. spin_unlock_irq(&mddev->write_lock);
  5817. }
  5818. if (did_change)
  5819. sysfs_notify_dirent_safe(mddev->sysfs_state);
  5820. wait_event(mddev->sb_wait,
  5821. !test_bit(MD_CHANGE_PENDING, &mddev->flags));
  5822. }
  5823. void md_write_end(mddev_t *mddev)
  5824. {
  5825. if (atomic_dec_and_test(&mddev->writes_pending)) {
  5826. if (mddev->safemode == 2)
  5827. md_wakeup_thread(mddev->thread);
  5828. else if (mddev->safemode_delay)
  5829. mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
  5830. }
  5831. }
  5832. /* md_allow_write(mddev)
  5833. * Calling this ensures that the array is marked 'active' so that writes
  5834. * may proceed without blocking. It is important to call this before
  5835. * attempting a GFP_KERNEL allocation while holding the mddev lock.
  5836. * Must be called with mddev_lock held.
  5837. *
  5838. * In the ->external case MD_CHANGE_CLEAN can not be cleared until mddev->lock
  5839. * is dropped, so return -EAGAIN after notifying userspace.
  5840. */
  5841. int md_allow_write(mddev_t *mddev)
  5842. {
  5843. if (!mddev->pers)
  5844. return 0;
  5845. if (mddev->ro)
  5846. return 0;
  5847. if (!mddev->pers->sync_request)
  5848. return 0;
  5849. spin_lock_irq(&mddev->write_lock);
  5850. if (mddev->in_sync) {
  5851. mddev->in_sync = 0;
  5852. set_bit(MD_CHANGE_CLEAN, &mddev->flags);
  5853. set_bit(MD_CHANGE_PENDING, &mddev->flags);
  5854. if (mddev->safemode_delay &&
  5855. mddev->safemode == 0)
  5856. mddev->safemode = 1;
  5857. spin_unlock_irq(&mddev->write_lock);
  5858. md_update_sb(mddev, 0);
  5859. sysfs_notify_dirent_safe(mddev->sysfs_state);
  5860. } else
  5861. spin_unlock_irq(&mddev->write_lock);
  5862. if (test_bit(MD_CHANGE_PENDING, &mddev->flags))
  5863. return -EAGAIN;
  5864. else
  5865. return 0;
  5866. }
  5867. EXPORT_SYMBOL_GPL(md_allow_write);
  5868. void md_unplug(mddev_t *mddev)
  5869. {
  5870. if (mddev->queue)
  5871. blk_unplug(mddev->queue);
  5872. if (mddev->plug)
  5873. mddev->plug->unplug_fn(mddev->plug);
  5874. }
  5875. #define SYNC_MARKS 10
  5876. #define SYNC_MARK_STEP (3*HZ)
  5877. void md_do_sync(mddev_t *mddev)
  5878. {
  5879. mddev_t *mddev2;
  5880. unsigned int currspeed = 0,
  5881. window;
  5882. sector_t max_sectors,j, io_sectors;
  5883. unsigned long mark[SYNC_MARKS];
  5884. sector_t mark_cnt[SYNC_MARKS];
  5885. int last_mark,m;
  5886. struct list_head *tmp;
  5887. sector_t last_check;
  5888. int skipped = 0;
  5889. mdk_rdev_t *rdev;
  5890. char *desc;
  5891. /* just incase thread restarts... */
  5892. if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
  5893. return;
  5894. if (mddev->ro) /* never try to sync a read-only array */
  5895. return;
  5896. if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
  5897. if (test_bit(MD_RECOVERY_CHECK, &mddev->recovery))
  5898. desc = "data-check";
  5899. else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
  5900. desc = "requested-resync";
  5901. else
  5902. desc = "resync";
  5903. } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
  5904. desc = "reshape";
  5905. else
  5906. desc = "recovery";
  5907. /* we overload curr_resync somewhat here.
  5908. * 0 == not engaged in resync at all
  5909. * 2 == checking that there is no conflict with another sync
  5910. * 1 == like 2, but have yielded to allow conflicting resync to
  5911. * commense
  5912. * other == active in resync - this many blocks
  5913. *
  5914. * Before starting a resync we must have set curr_resync to
  5915. * 2, and then checked that every "conflicting" array has curr_resync
  5916. * less than ours. When we find one that is the same or higher
  5917. * we wait on resync_wait. To avoid deadlock, we reduce curr_resync
  5918. * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
  5919. * This will mean we have to start checking from the beginning again.
  5920. *
  5921. */
  5922. do {
  5923. mddev->curr_resync = 2;
  5924. try_again:
  5925. if (kthread_should_stop())
  5926. set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  5927. if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
  5928. goto skip;
  5929. for_each_mddev(mddev2, tmp) {
  5930. if (mddev2 == mddev)
  5931. continue;
  5932. if (!mddev->parallel_resync
  5933. && mddev2->curr_resync
  5934. && match_mddev_units(mddev, mddev2)) {
  5935. DEFINE_WAIT(wq);
  5936. if (mddev < mddev2 && mddev->curr_resync == 2) {
  5937. /* arbitrarily yield */
  5938. mddev->curr_resync = 1;
  5939. wake_up(&resync_wait);
  5940. }
  5941. if (mddev > mddev2 && mddev->curr_resync == 1)
  5942. /* no need to wait here, we can wait the next
  5943. * time 'round when curr_resync == 2
  5944. */
  5945. continue;
  5946. /* We need to wait 'interruptible' so as not to
  5947. * contribute to the load average, and not to
  5948. * be caught by 'softlockup'
  5949. */
  5950. prepare_to_wait(&resync_wait, &wq, TASK_INTERRUPTIBLE);
  5951. if (!kthread_should_stop() &&
  5952. mddev2->curr_resync >= mddev->curr_resync) {
  5953. printk(KERN_INFO "md: delaying %s of %s"
  5954. " until %s has finished (they"
  5955. " share one or more physical units)\n",
  5956. desc, mdname(mddev), mdname(mddev2));
  5957. mddev_put(mddev2);
  5958. if (signal_pending(current))
  5959. flush_signals(current);
  5960. schedule();
  5961. finish_wait(&resync_wait, &wq);
  5962. goto try_again;
  5963. }
  5964. finish_wait(&resync_wait, &wq);
  5965. }
  5966. }
  5967. } while (mddev->curr_resync < 2);
  5968. j = 0;
  5969. if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
  5970. /* resync follows the size requested by the personality,
  5971. * which defaults to physical size, but can be virtual size
  5972. */
  5973. max_sectors = mddev->resync_max_sectors;
  5974. mddev->resync_mismatches = 0;
  5975. /* we don't use the checkpoint if there's a bitmap */
  5976. if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
  5977. j = mddev->resync_min;
  5978. else if (!mddev->bitmap)
  5979. j = mddev->recovery_cp;
  5980. } else if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery))
  5981. max_sectors = mddev->dev_sectors;
  5982. else {
  5983. /* recovery follows the physical size of devices */
  5984. max_sectors = mddev->dev_sectors;
  5985. j = MaxSector;
  5986. rcu_read_lock();
  5987. list_for_each_entry_rcu(rdev, &mddev->disks, same_set)
  5988. if (rdev->raid_disk >= 0 &&
  5989. !test_bit(Faulty, &rdev->flags) &&
  5990. !test_bit(In_sync, &rdev->flags) &&
  5991. rdev->recovery_offset < j)
  5992. j = rdev->recovery_offset;
  5993. rcu_read_unlock();
  5994. }
  5995. printk(KERN_INFO "md: %s of RAID array %s\n", desc, mdname(mddev));
  5996. printk(KERN_INFO "md: minimum _guaranteed_ speed:"
  5997. " %d KB/sec/disk.\n", speed_min(mddev));
  5998. printk(KERN_INFO "md: using maximum available idle IO bandwidth "
  5999. "(but not more than %d KB/sec) for %s.\n",
  6000. speed_max(mddev), desc);
  6001. is_mddev_idle(mddev, 1); /* this initializes IO event counters */
  6002. io_sectors = 0;
  6003. for (m = 0; m < SYNC_MARKS; m++) {
  6004. mark[m] = jiffies;
  6005. mark_cnt[m] = io_sectors;
  6006. }
  6007. last_mark = 0;
  6008. mddev->resync_mark = mark[last_mark];
  6009. mddev->resync_mark_cnt = mark_cnt[last_mark];
  6010. /*
  6011. * Tune reconstruction:
  6012. */
  6013. window = 32*(PAGE_SIZE/512);
  6014. printk(KERN_INFO "md: using %dk window, over a total of %llu blocks.\n",
  6015. window/2,(unsigned long long) max_sectors/2);
  6016. atomic_set(&mddev->recovery_active, 0);
  6017. last_check = 0;
  6018. if (j>2) {
  6019. printk(KERN_INFO
  6020. "md: resuming %s of %s from checkpoint.\n",
  6021. desc, mdname(mddev));
  6022. mddev->curr_resync = j;
  6023. }
  6024. mddev->curr_resync_completed = mddev->curr_resync;
  6025. while (j < max_sectors) {
  6026. sector_t sectors;
  6027. skipped = 0;
  6028. if (!test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
  6029. ((mddev->curr_resync > mddev->curr_resync_completed &&
  6030. (mddev->curr_resync - mddev->curr_resync_completed)
  6031. > (max_sectors >> 4)) ||
  6032. (j - mddev->curr_resync_completed)*2
  6033. >= mddev->resync_max - mddev->curr_resync_completed
  6034. )) {
  6035. /* time to update curr_resync_completed */
  6036. md_unplug(mddev);
  6037. wait_event(mddev->recovery_wait,
  6038. atomic_read(&mddev->recovery_active) == 0);
  6039. mddev->curr_resync_completed =
  6040. mddev->curr_resync;
  6041. set_bit(MD_CHANGE_CLEAN, &mddev->flags);
  6042. sysfs_notify(&mddev->kobj, NULL, "sync_completed");
  6043. }
  6044. while (j >= mddev->resync_max && !kthread_should_stop()) {
  6045. /* As this condition is controlled by user-space,
  6046. * we can block indefinitely, so use '_interruptible'
  6047. * to avoid triggering warnings.
  6048. */
  6049. flush_signals(current); /* just in case */
  6050. wait_event_interruptible(mddev->recovery_wait,
  6051. mddev->resync_max > j
  6052. || kthread_should_stop());
  6053. }
  6054. if (kthread_should_stop())
  6055. goto interrupted;
  6056. sectors = mddev->pers->sync_request(mddev, j, &skipped,
  6057. currspeed < speed_min(mddev));
  6058. if (sectors == 0) {
  6059. set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  6060. goto out;
  6061. }
  6062. if (!skipped) { /* actual IO requested */
  6063. io_sectors += sectors;
  6064. atomic_add(sectors, &mddev->recovery_active);
  6065. }
  6066. j += sectors;
  6067. if (j>1) mddev->curr_resync = j;
  6068. mddev->curr_mark_cnt = io_sectors;
  6069. if (last_check == 0)
  6070. /* this is the earliers that rebuilt will be
  6071. * visible in /proc/mdstat
  6072. */
  6073. md_new_event(mddev);
  6074. if (last_check + window > io_sectors || j == max_sectors)
  6075. continue;
  6076. last_check = io_sectors;
  6077. if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
  6078. break;
  6079. repeat:
  6080. if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
  6081. /* step marks */
  6082. int next = (last_mark+1) % SYNC_MARKS;
  6083. mddev->resync_mark = mark[next];
  6084. mddev->resync_mark_cnt = mark_cnt[next];
  6085. mark[next] = jiffies;
  6086. mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
  6087. last_mark = next;
  6088. }
  6089. if (kthread_should_stop())
  6090. goto interrupted;
  6091. /*
  6092. * this loop exits only if either when we are slower than
  6093. * the 'hard' speed limit, or the system was IO-idle for
  6094. * a jiffy.
  6095. * the system might be non-idle CPU-wise, but we only care
  6096. * about not overloading the IO subsystem. (things like an
  6097. * e2fsck being done on the RAID array should execute fast)
  6098. */
  6099. md_unplug(mddev);
  6100. cond_resched();
  6101. currspeed = ((unsigned long)(io_sectors-mddev->resync_mark_cnt))/2
  6102. /((jiffies-mddev->resync_mark)/HZ +1) +1;
  6103. if (currspeed > speed_min(mddev)) {
  6104. if ((currspeed > speed_max(mddev)) ||
  6105. !is_mddev_idle(mddev, 0)) {
  6106. msleep(500);
  6107. goto repeat;
  6108. }
  6109. }
  6110. }
  6111. printk(KERN_INFO "md: %s: %s done.\n",mdname(mddev), desc);
  6112. /*
  6113. * this also signals 'finished resyncing' to md_stop
  6114. */
  6115. out:
  6116. md_unplug(mddev);
  6117. wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
  6118. /* tell personality that we are finished */
  6119. mddev->pers->sync_request(mddev, max_sectors, &skipped, 1);
  6120. if (!test_bit(MD_RECOVERY_CHECK, &mddev->recovery) &&
  6121. mddev->curr_resync > 2) {
  6122. if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery)) {
  6123. if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
  6124. if (mddev->curr_resync >= mddev->recovery_cp) {
  6125. printk(KERN_INFO
  6126. "md: checkpointing %s of %s.\n",
  6127. desc, mdname(mddev));
  6128. mddev->recovery_cp = mddev->curr_resync;
  6129. }
  6130. } else
  6131. mddev->recovery_cp = MaxSector;
  6132. } else {
  6133. if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
  6134. mddev->curr_resync = MaxSector;
  6135. rcu_read_lock();
  6136. list_for_each_entry_rcu(rdev, &mddev->disks, same_set)
  6137. if (rdev->raid_disk >= 0 &&
  6138. mddev->delta_disks >= 0 &&
  6139. !test_bit(Faulty, &rdev->flags) &&
  6140. !test_bit(In_sync, &rdev->flags) &&
  6141. rdev->recovery_offset < mddev->curr_resync)
  6142. rdev->recovery_offset = mddev->curr_resync;
  6143. rcu_read_unlock();
  6144. }
  6145. }
  6146. set_bit(MD_CHANGE_DEVS, &mddev->flags);
  6147. skip:
  6148. if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
  6149. /* We completed so min/max setting can be forgotten if used. */
  6150. if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
  6151. mddev->resync_min = 0;
  6152. mddev->resync_max = MaxSector;
  6153. } else if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
  6154. mddev->resync_min = mddev->curr_resync_completed;
  6155. mddev->curr_resync = 0;
  6156. if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery))
  6157. mddev->curr_resync_completed = 0;
  6158. sysfs_notify(&mddev->kobj, NULL, "sync_completed");
  6159. wake_up(&resync_wait);
  6160. set_bit(MD_RECOVERY_DONE, &mddev->recovery);
  6161. md_wakeup_thread(mddev->thread);
  6162. return;
  6163. interrupted:
  6164. /*
  6165. * got a signal, exit.
  6166. */
  6167. printk(KERN_INFO
  6168. "md: md_do_sync() got signal ... exiting\n");
  6169. set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  6170. goto out;
  6171. }
  6172. EXPORT_SYMBOL_GPL(md_do_sync);
  6173. static int remove_and_add_spares(mddev_t *mddev)
  6174. {
  6175. mdk_rdev_t *rdev;
  6176. int spares = 0;
  6177. mddev->curr_resync_completed = 0;
  6178. list_for_each_entry(rdev, &mddev->disks, same_set)
  6179. if (rdev->raid_disk >= 0 &&
  6180. !test_bit(Blocked, &rdev->flags) &&
  6181. (test_bit(Faulty, &rdev->flags) ||
  6182. ! test_bit(In_sync, &rdev->flags)) &&
  6183. atomic_read(&rdev->nr_pending)==0) {
  6184. if (mddev->pers->hot_remove_disk(
  6185. mddev, rdev->raid_disk)==0) {
  6186. char nm[20];
  6187. sprintf(nm,"rd%d", rdev->raid_disk);
  6188. sysfs_remove_link(&mddev->kobj, nm);
  6189. rdev->raid_disk = -1;
  6190. }
  6191. }
  6192. if (mddev->degraded && ! mddev->ro && !mddev->recovery_disabled) {
  6193. list_for_each_entry(rdev, &mddev->disks, same_set) {
  6194. if (rdev->raid_disk >= 0 &&
  6195. !test_bit(In_sync, &rdev->flags) &&
  6196. !test_bit(Blocked, &rdev->flags))
  6197. spares++;
  6198. if (rdev->raid_disk < 0
  6199. && !test_bit(Faulty, &rdev->flags)) {
  6200. rdev->recovery_offset = 0;
  6201. if (mddev->pers->
  6202. hot_add_disk(mddev, rdev) == 0) {
  6203. char nm[20];
  6204. sprintf(nm, "rd%d", rdev->raid_disk);
  6205. if (sysfs_create_link(&mddev->kobj,
  6206. &rdev->kobj, nm))
  6207. /* failure here is OK */;
  6208. spares++;
  6209. md_new_event(mddev);
  6210. set_bit(MD_CHANGE_DEVS, &mddev->flags);
  6211. } else
  6212. break;
  6213. }
  6214. }
  6215. }
  6216. return spares;
  6217. }
  6218. /*
  6219. * This routine is regularly called by all per-raid-array threads to
  6220. * deal with generic issues like resync and super-block update.
  6221. * Raid personalities that don't have a thread (linear/raid0) do not
  6222. * need this as they never do any recovery or update the superblock.
  6223. *
  6224. * It does not do any resync itself, but rather "forks" off other threads
  6225. * to do that as needed.
  6226. * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in
  6227. * "->recovery" and create a thread at ->sync_thread.
  6228. * When the thread finishes it sets MD_RECOVERY_DONE
  6229. * and wakeups up this thread which will reap the thread and finish up.
  6230. * This thread also removes any faulty devices (with nr_pending == 0).
  6231. *
  6232. * The overall approach is:
  6233. * 1/ if the superblock needs updating, update it.
  6234. * 2/ If a recovery thread is running, don't do anything else.
  6235. * 3/ If recovery has finished, clean up, possibly marking spares active.
  6236. * 4/ If there are any faulty devices, remove them.
  6237. * 5/ If array is degraded, try to add spares devices
  6238. * 6/ If array has spares or is not in-sync, start a resync thread.
  6239. */
  6240. void md_check_recovery(mddev_t *mddev)
  6241. {
  6242. mdk_rdev_t *rdev;
  6243. if (mddev->bitmap)
  6244. bitmap_daemon_work(mddev);
  6245. if (mddev->ro)
  6246. return;
  6247. if (signal_pending(current)) {
  6248. if (mddev->pers->sync_request && !mddev->external) {
  6249. printk(KERN_INFO "md: %s in immediate safe mode\n",
  6250. mdname(mddev));
  6251. mddev->safemode = 2;
  6252. }
  6253. flush_signals(current);
  6254. }
  6255. if (mddev->ro && !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
  6256. return;
  6257. if ( ! (
  6258. (mddev->flags && !mddev->external) ||
  6259. test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
  6260. test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
  6261. (mddev->external == 0 && mddev->safemode == 1) ||
  6262. (mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
  6263. && !mddev->in_sync && mddev->recovery_cp == MaxSector)
  6264. ))
  6265. return;
  6266. if (mddev_trylock(mddev)) {
  6267. int spares = 0;
  6268. if (mddev->ro) {
  6269. /* Only thing we do on a ro array is remove
  6270. * failed devices.
  6271. */
  6272. remove_and_add_spares(mddev);
  6273. clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  6274. goto unlock;
  6275. }
  6276. if (!mddev->external) {
  6277. int did_change = 0;
  6278. spin_lock_irq(&mddev->write_lock);
  6279. if (mddev->safemode &&
  6280. !atomic_read(&mddev->writes_pending) &&
  6281. !mddev->in_sync &&
  6282. mddev->recovery_cp == MaxSector) {
  6283. mddev->in_sync = 1;
  6284. did_change = 1;
  6285. set_bit(MD_CHANGE_CLEAN, &mddev->flags);
  6286. }
  6287. if (mddev->safemode == 1)
  6288. mddev->safemode = 0;
  6289. spin_unlock_irq(&mddev->write_lock);
  6290. if (did_change)
  6291. sysfs_notify_dirent_safe(mddev->sysfs_state);
  6292. }
  6293. if (mddev->flags)
  6294. md_update_sb(mddev, 0);
  6295. if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
  6296. !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
  6297. /* resync/recovery still happening */
  6298. clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  6299. goto unlock;
  6300. }
  6301. if (mddev->sync_thread) {
  6302. /* resync has finished, collect result */
  6303. md_unregister_thread(mddev->sync_thread);
  6304. mddev->sync_thread = NULL;
  6305. if (!test_bit(MD_RECOVERY_INTR, &mddev->recovery) &&
  6306. !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
  6307. /* success...*/
  6308. /* activate any spares */
  6309. if (mddev->pers->spare_active(mddev))
  6310. sysfs_notify(&mddev->kobj, NULL,
  6311. "degraded");
  6312. }
  6313. if (test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) &&
  6314. mddev->pers->finish_reshape)
  6315. mddev->pers->finish_reshape(mddev);
  6316. md_update_sb(mddev, 1);
  6317. /* if array is no-longer degraded, then any saved_raid_disk
  6318. * information must be scrapped
  6319. */
  6320. if (!mddev->degraded)
  6321. list_for_each_entry(rdev, &mddev->disks, same_set)
  6322. rdev->saved_raid_disk = -1;
  6323. mddev->recovery = 0;
  6324. /* flag recovery needed just to double check */
  6325. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  6326. sysfs_notify_dirent_safe(mddev->sysfs_action);
  6327. md_new_event(mddev);
  6328. goto unlock;
  6329. }
  6330. /* Set RUNNING before clearing NEEDED to avoid
  6331. * any transients in the value of "sync_action".
  6332. */
  6333. set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
  6334. clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  6335. /* Clear some bits that don't mean anything, but
  6336. * might be left set
  6337. */
  6338. clear_bit(MD_RECOVERY_INTR, &mddev->recovery);
  6339. clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
  6340. if (test_bit(MD_RECOVERY_FROZEN, &mddev->recovery))
  6341. goto unlock;
  6342. /* no recovery is running.
  6343. * remove any failed drives, then
  6344. * add spares if possible.
  6345. * Spare are also removed and re-added, to allow
  6346. * the personality to fail the re-add.
  6347. */
  6348. if (mddev->reshape_position != MaxSector) {
  6349. if (mddev->pers->check_reshape == NULL ||
  6350. mddev->pers->check_reshape(mddev) != 0)
  6351. /* Cannot proceed */
  6352. goto unlock;
  6353. set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
  6354. clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
  6355. } else if ((spares = remove_and_add_spares(mddev))) {
  6356. clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
  6357. clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
  6358. clear_bit(MD_RECOVERY_REQUESTED, &mddev->recovery);
  6359. set_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
  6360. } else if (mddev->recovery_cp < MaxSector) {
  6361. set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
  6362. clear_bit(MD_RECOVERY_RECOVER, &mddev->recovery);
  6363. } else if (!test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
  6364. /* nothing to be done ... */
  6365. goto unlock;
  6366. if (mddev->pers->sync_request) {
  6367. if (spares && mddev->bitmap && ! mddev->bitmap->file) {
  6368. /* We are adding a device or devices to an array
  6369. * which has the bitmap stored on all devices.
  6370. * So make sure all bitmap pages get written
  6371. */
  6372. bitmap_write_all(mddev->bitmap);
  6373. }
  6374. mddev->sync_thread = md_register_thread(md_do_sync,
  6375. mddev,
  6376. "resync");
  6377. if (!mddev->sync_thread) {
  6378. printk(KERN_ERR "%s: could not start resync"
  6379. " thread...\n",
  6380. mdname(mddev));
  6381. /* leave the spares where they are, it shouldn't hurt */
  6382. mddev->recovery = 0;
  6383. } else
  6384. md_wakeup_thread(mddev->sync_thread);
  6385. sysfs_notify_dirent_safe(mddev->sysfs_action);
  6386. md_new_event(mddev);
  6387. }
  6388. unlock:
  6389. if (!mddev->sync_thread) {
  6390. clear_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
  6391. if (test_and_clear_bit(MD_RECOVERY_RECOVER,
  6392. &mddev->recovery))
  6393. if (mddev->sysfs_action)
  6394. sysfs_notify_dirent_safe(mddev->sysfs_action);
  6395. }
  6396. mddev_unlock(mddev);
  6397. }
  6398. }
  6399. void md_wait_for_blocked_rdev(mdk_rdev_t *rdev, mddev_t *mddev)
  6400. {
  6401. sysfs_notify_dirent_safe(rdev->sysfs_state);
  6402. wait_event_timeout(rdev->blocked_wait,
  6403. !test_bit(Blocked, &rdev->flags),
  6404. msecs_to_jiffies(5000));
  6405. rdev_dec_pending(rdev, mddev);
  6406. }
  6407. EXPORT_SYMBOL(md_wait_for_blocked_rdev);
  6408. static int md_notify_reboot(struct notifier_block *this,
  6409. unsigned long code, void *x)
  6410. {
  6411. struct list_head *tmp;
  6412. mddev_t *mddev;
  6413. if ((code == SYS_DOWN) || (code == SYS_HALT) || (code == SYS_POWER_OFF)) {
  6414. printk(KERN_INFO "md: stopping all md devices.\n");
  6415. for_each_mddev(mddev, tmp)
  6416. if (mddev_trylock(mddev)) {
  6417. /* Force a switch to readonly even array
  6418. * appears to still be in use. Hence
  6419. * the '100'.
  6420. */
  6421. md_set_readonly(mddev, 100);
  6422. mddev_unlock(mddev);
  6423. }
  6424. /*
  6425. * certain more exotic SCSI devices are known to be
  6426. * volatile wrt too early system reboots. While the
  6427. * right place to handle this issue is the given
  6428. * driver, we do want to have a safe RAID driver ...
  6429. */
  6430. mdelay(1000*1);
  6431. }
  6432. return NOTIFY_DONE;
  6433. }
  6434. static struct notifier_block md_notifier = {
  6435. .notifier_call = md_notify_reboot,
  6436. .next = NULL,
  6437. .priority = INT_MAX, /* before any real devices */
  6438. };
  6439. static void md_geninit(void)
  6440. {
  6441. dprintk("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
  6442. proc_create("mdstat", S_IRUGO, NULL, &md_seq_fops);
  6443. }
  6444. static int __init md_init(void)
  6445. {
  6446. if (register_blkdev(MD_MAJOR, "md"))
  6447. return -1;
  6448. if ((mdp_major=register_blkdev(0, "mdp"))<=0) {
  6449. unregister_blkdev(MD_MAJOR, "md");
  6450. return -1;
  6451. }
  6452. blk_register_region(MKDEV(MD_MAJOR, 0), 1UL<<MINORBITS, THIS_MODULE,
  6453. md_probe, NULL, NULL);
  6454. blk_register_region(MKDEV(mdp_major, 0), 1UL<<MINORBITS, THIS_MODULE,
  6455. md_probe, NULL, NULL);
  6456. register_reboot_notifier(&md_notifier);
  6457. raid_table_header = register_sysctl_table(raid_root_table);
  6458. md_geninit();
  6459. return 0;
  6460. }
  6461. #ifndef MODULE
  6462. /*
  6463. * Searches all registered partitions for autorun RAID arrays
  6464. * at boot time.
  6465. */
  6466. static LIST_HEAD(all_detected_devices);
  6467. struct detected_devices_node {
  6468. struct list_head list;
  6469. dev_t dev;
  6470. };
  6471. void md_autodetect_dev(dev_t dev)
  6472. {
  6473. struct detected_devices_node *node_detected_dev;
  6474. node_detected_dev = kzalloc(sizeof(*node_detected_dev), GFP_KERNEL);
  6475. if (node_detected_dev) {
  6476. node_detected_dev->dev = dev;
  6477. list_add_tail(&node_detected_dev->list, &all_detected_devices);
  6478. } else {
  6479. printk(KERN_CRIT "md: md_autodetect_dev: kzalloc failed"
  6480. ", skipping dev(%d,%d)\n", MAJOR(dev), MINOR(dev));
  6481. }
  6482. }
  6483. static void autostart_arrays(int part)
  6484. {
  6485. mdk_rdev_t *rdev;
  6486. struct detected_devices_node *node_detected_dev;
  6487. dev_t dev;
  6488. int i_scanned, i_passed;
  6489. i_scanned = 0;
  6490. i_passed = 0;
  6491. printk(KERN_INFO "md: Autodetecting RAID arrays.\n");
  6492. while (!list_empty(&all_detected_devices) && i_scanned < INT_MAX) {
  6493. i_scanned++;
  6494. node_detected_dev = list_entry(all_detected_devices.next,
  6495. struct detected_devices_node, list);
  6496. list_del(&node_detected_dev->list);
  6497. dev = node_detected_dev->dev;
  6498. kfree(node_detected_dev);
  6499. rdev = md_import_device(dev,0, 90);
  6500. if (IS_ERR(rdev))
  6501. continue;
  6502. if (test_bit(Faulty, &rdev->flags)) {
  6503. MD_BUG();
  6504. continue;
  6505. }
  6506. set_bit(AutoDetected, &rdev->flags);
  6507. list_add(&rdev->same_set, &pending_raid_disks);
  6508. i_passed++;
  6509. }
  6510. printk(KERN_INFO "md: Scanned %d and added %d devices.\n",
  6511. i_scanned, i_passed);
  6512. autorun_devices(part);
  6513. }
  6514. #endif /* !MODULE */
  6515. static __exit void md_exit(void)
  6516. {
  6517. mddev_t *mddev;
  6518. struct list_head *tmp;
  6519. blk_unregister_region(MKDEV(MD_MAJOR,0), 1U << MINORBITS);
  6520. blk_unregister_region(MKDEV(mdp_major,0), 1U << MINORBITS);
  6521. unregister_blkdev(MD_MAJOR,"md");
  6522. unregister_blkdev(mdp_major, "mdp");
  6523. unregister_reboot_notifier(&md_notifier);
  6524. unregister_sysctl_table(raid_table_header);
  6525. remove_proc_entry("mdstat", NULL);
  6526. for_each_mddev(mddev, tmp) {
  6527. export_array(mddev);
  6528. mddev->hold_active = 0;
  6529. }
  6530. }
  6531. subsys_initcall(md_init);
  6532. module_exit(md_exit)
  6533. static int get_ro(char *buffer, struct kernel_param *kp)
  6534. {
  6535. return sprintf(buffer, "%d", start_readonly);
  6536. }
  6537. static int set_ro(const char *val, struct kernel_param *kp)
  6538. {
  6539. char *e;
  6540. int num = simple_strtoul(val, &e, 10);
  6541. if (*val && (*e == '\0' || *e == '\n')) {
  6542. start_readonly = num;
  6543. return 0;
  6544. }
  6545. return -EINVAL;
  6546. }
  6547. module_param_call(start_ro, set_ro, get_ro, NULL, S_IRUSR|S_IWUSR);
  6548. module_param(start_dirty_degraded, int, S_IRUGO|S_IWUSR);
  6549. module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR);
  6550. EXPORT_SYMBOL(register_md_personality);
  6551. EXPORT_SYMBOL(unregister_md_personality);
  6552. EXPORT_SYMBOL(md_error);
  6553. EXPORT_SYMBOL(md_done_sync);
  6554. EXPORT_SYMBOL(md_write_start);
  6555. EXPORT_SYMBOL(md_write_end);
  6556. EXPORT_SYMBOL(md_register_thread);
  6557. EXPORT_SYMBOL(md_unregister_thread);
  6558. EXPORT_SYMBOL(md_wakeup_thread);
  6559. EXPORT_SYMBOL(md_check_recovery);
  6560. MODULE_LICENSE("GPL");
  6561. MODULE_DESCRIPTION("MD RAID framework");
  6562. MODULE_ALIAS("md");
  6563. MODULE_ALIAS_BLOCKDEV_MAJOR(MD_MAJOR);