md.c 261 KB

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