md.c 95 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011
  1. /*
  2. md.c : Multiple Devices driver for Linux
  3. Copyright (C) 1998, 1999, 2000 Ingo Molnar
  4. completely rewritten, based on the MD driver code from Marc Zyngier
  5. Changes:
  6. - RAID-1/RAID-5 extensions by Miguel de Icaza, Gadi Oxman, Ingo Molnar
  7. - RAID-6 extensions by H. Peter Anvin <hpa@zytor.com>
  8. - boot support for linear and striped mode by Harald Hoyer <HarryH@Royal.Net>
  9. - kerneld support by Boris Tobotras <boris@xtalk.msk.su>
  10. - kmod support by: Cyrus Durgin
  11. - RAID0 bugfixes: Mark Anthony Lisher <markal@iname.com>
  12. - Devfs support by Richard Gooch <rgooch@atnf.csiro.au>
  13. - lots of fixes and improvements to the RAID1/RAID5 and generic
  14. RAID code (such as request based resynchronization):
  15. Neil Brown <neilb@cse.unsw.edu.au>.
  16. - persistent bitmap code
  17. Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.
  18. This program is free software; you can redistribute it and/or modify
  19. it under the terms of the GNU General Public License as published by
  20. the Free Software Foundation; either version 2, or (at your option)
  21. any later version.
  22. You should have received a copy of the GNU General Public License
  23. (for example /usr/src/linux/COPYING); if not, write to the Free
  24. Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25. */
  26. #include <linux/module.h>
  27. #include <linux/config.h>
  28. #include <linux/linkage.h>
  29. #include <linux/raid/md.h>
  30. #include <linux/raid/bitmap.h>
  31. #include <linux/sysctl.h>
  32. #include <linux/devfs_fs_kernel.h>
  33. #include <linux/buffer_head.h> /* for invalidate_bdev */
  34. #include <linux/suspend.h>
  35. #include <linux/init.h>
  36. #include <linux/file.h>
  37. #ifdef CONFIG_KMOD
  38. #include <linux/kmod.h>
  39. #endif
  40. #include <asm/unaligned.h>
  41. #define MAJOR_NR MD_MAJOR
  42. #define MD_DRIVER
  43. /* 63 partitions with the alternate major number (mdp) */
  44. #define MdpMinorShift 6
  45. #define DEBUG 0
  46. #define dprintk(x...) ((void)(DEBUG && printk(x)))
  47. #ifndef MODULE
  48. static void autostart_arrays (int part);
  49. #endif
  50. static mdk_personality_t *pers[MAX_PERSONALITY];
  51. static DEFINE_SPINLOCK(pers_lock);
  52. /*
  53. * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
  54. * is 1000 KB/sec, so the extra system load does not show up that much.
  55. * Increase it if you want to have more _guaranteed_ speed. Note that
  56. * the RAID driver will use the maximum available bandwith if the IO
  57. * subsystem is idle. There is also an 'absolute maximum' reconstruction
  58. * speed limit - in case reconstruction slows down your system despite
  59. * idle IO detection.
  60. *
  61. * you can change it via /proc/sys/dev/raid/speed_limit_min and _max.
  62. */
  63. static int sysctl_speed_limit_min = 1000;
  64. static int sysctl_speed_limit_max = 200000;
  65. static struct ctl_table_header *raid_table_header;
  66. static ctl_table raid_table[] = {
  67. {
  68. .ctl_name = DEV_RAID_SPEED_LIMIT_MIN,
  69. .procname = "speed_limit_min",
  70. .data = &sysctl_speed_limit_min,
  71. .maxlen = sizeof(int),
  72. .mode = 0644,
  73. .proc_handler = &proc_dointvec,
  74. },
  75. {
  76. .ctl_name = DEV_RAID_SPEED_LIMIT_MAX,
  77. .procname = "speed_limit_max",
  78. .data = &sysctl_speed_limit_max,
  79. .maxlen = sizeof(int),
  80. .mode = 0644,
  81. .proc_handler = &proc_dointvec,
  82. },
  83. { .ctl_name = 0 }
  84. };
  85. static ctl_table raid_dir_table[] = {
  86. {
  87. .ctl_name = DEV_RAID,
  88. .procname = "raid",
  89. .maxlen = 0,
  90. .mode = 0555,
  91. .child = raid_table,
  92. },
  93. { .ctl_name = 0 }
  94. };
  95. static ctl_table raid_root_table[] = {
  96. {
  97. .ctl_name = CTL_DEV,
  98. .procname = "dev",
  99. .maxlen = 0,
  100. .mode = 0555,
  101. .child = raid_dir_table,
  102. },
  103. { .ctl_name = 0 }
  104. };
  105. static struct block_device_operations md_fops;
  106. /*
  107. * Enables to iterate over all existing md arrays
  108. * all_mddevs_lock protects this list.
  109. */
  110. static LIST_HEAD(all_mddevs);
  111. static DEFINE_SPINLOCK(all_mddevs_lock);
  112. /*
  113. * iterates through all used mddevs in the system.
  114. * We take care to grab the all_mddevs_lock whenever navigating
  115. * the list, and to always hold a refcount when unlocked.
  116. * Any code which breaks out of this loop while own
  117. * a reference to the current mddev and must mddev_put it.
  118. */
  119. #define ITERATE_MDDEV(mddev,tmp) \
  120. \
  121. for (({ spin_lock(&all_mddevs_lock); \
  122. tmp = all_mddevs.next; \
  123. mddev = NULL;}); \
  124. ({ if (tmp != &all_mddevs) \
  125. mddev_get(list_entry(tmp, mddev_t, all_mddevs));\
  126. spin_unlock(&all_mddevs_lock); \
  127. if (mddev) mddev_put(mddev); \
  128. mddev = list_entry(tmp, mddev_t, all_mddevs); \
  129. tmp != &all_mddevs;}); \
  130. ({ spin_lock(&all_mddevs_lock); \
  131. tmp = tmp->next;}) \
  132. )
  133. static int md_fail_request (request_queue_t *q, struct bio *bio)
  134. {
  135. bio_io_error(bio, bio->bi_size);
  136. return 0;
  137. }
  138. static inline mddev_t *mddev_get(mddev_t *mddev)
  139. {
  140. atomic_inc(&mddev->active);
  141. return mddev;
  142. }
  143. static void mddev_put(mddev_t *mddev)
  144. {
  145. if (!atomic_dec_and_lock(&mddev->active, &all_mddevs_lock))
  146. return;
  147. if (!mddev->raid_disks && list_empty(&mddev->disks)) {
  148. list_del(&mddev->all_mddevs);
  149. blk_put_queue(mddev->queue);
  150. kfree(mddev);
  151. }
  152. spin_unlock(&all_mddevs_lock);
  153. }
  154. static mddev_t * mddev_find(dev_t unit)
  155. {
  156. mddev_t *mddev, *new = NULL;
  157. retry:
  158. spin_lock(&all_mddevs_lock);
  159. list_for_each_entry(mddev, &all_mddevs, all_mddevs)
  160. if (mddev->unit == unit) {
  161. mddev_get(mddev);
  162. spin_unlock(&all_mddevs_lock);
  163. kfree(new);
  164. return mddev;
  165. }
  166. if (new) {
  167. list_add(&new->all_mddevs, &all_mddevs);
  168. spin_unlock(&all_mddevs_lock);
  169. return new;
  170. }
  171. spin_unlock(&all_mddevs_lock);
  172. new = (mddev_t *) kmalloc(sizeof(*new), GFP_KERNEL);
  173. if (!new)
  174. return NULL;
  175. memset(new, 0, sizeof(*new));
  176. new->unit = unit;
  177. if (MAJOR(unit) == MD_MAJOR)
  178. new->md_minor = MINOR(unit);
  179. else
  180. new->md_minor = MINOR(unit) >> MdpMinorShift;
  181. init_MUTEX(&new->reconfig_sem);
  182. INIT_LIST_HEAD(&new->disks);
  183. INIT_LIST_HEAD(&new->all_mddevs);
  184. init_timer(&new->safemode_timer);
  185. atomic_set(&new->active, 1);
  186. spin_lock_init(&new->write_lock);
  187. init_waitqueue_head(&new->sb_wait);
  188. new->queue = blk_alloc_queue(GFP_KERNEL);
  189. if (!new->queue) {
  190. kfree(new);
  191. return NULL;
  192. }
  193. blk_queue_make_request(new->queue, md_fail_request);
  194. goto retry;
  195. }
  196. static inline int mddev_lock(mddev_t * mddev)
  197. {
  198. return down_interruptible(&mddev->reconfig_sem);
  199. }
  200. static inline void mddev_lock_uninterruptible(mddev_t * mddev)
  201. {
  202. down(&mddev->reconfig_sem);
  203. }
  204. static inline int mddev_trylock(mddev_t * mddev)
  205. {
  206. return down_trylock(&mddev->reconfig_sem);
  207. }
  208. static inline void mddev_unlock(mddev_t * mddev)
  209. {
  210. up(&mddev->reconfig_sem);
  211. if (mddev->thread)
  212. md_wakeup_thread(mddev->thread);
  213. }
  214. mdk_rdev_t * find_rdev_nr(mddev_t *mddev, int nr)
  215. {
  216. mdk_rdev_t * rdev;
  217. struct list_head *tmp;
  218. ITERATE_RDEV(mddev,rdev,tmp) {
  219. if (rdev->desc_nr == nr)
  220. return rdev;
  221. }
  222. return NULL;
  223. }
  224. static mdk_rdev_t * find_rdev(mddev_t * mddev, dev_t dev)
  225. {
  226. struct list_head *tmp;
  227. mdk_rdev_t *rdev;
  228. ITERATE_RDEV(mddev,rdev,tmp) {
  229. if (rdev->bdev->bd_dev == dev)
  230. return rdev;
  231. }
  232. return NULL;
  233. }
  234. static inline sector_t calc_dev_sboffset(struct block_device *bdev)
  235. {
  236. sector_t size = bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
  237. return MD_NEW_SIZE_BLOCKS(size);
  238. }
  239. static sector_t calc_dev_size(mdk_rdev_t *rdev, unsigned chunk_size)
  240. {
  241. sector_t size;
  242. size = rdev->sb_offset;
  243. if (chunk_size)
  244. size &= ~((sector_t)chunk_size/1024 - 1);
  245. return size;
  246. }
  247. static int alloc_disk_sb(mdk_rdev_t * rdev)
  248. {
  249. if (rdev->sb_page)
  250. MD_BUG();
  251. rdev->sb_page = alloc_page(GFP_KERNEL);
  252. if (!rdev->sb_page) {
  253. printk(KERN_ALERT "md: out of memory.\n");
  254. return -EINVAL;
  255. }
  256. return 0;
  257. }
  258. static void free_disk_sb(mdk_rdev_t * rdev)
  259. {
  260. if (rdev->sb_page) {
  261. page_cache_release(rdev->sb_page);
  262. rdev->sb_loaded = 0;
  263. rdev->sb_page = NULL;
  264. rdev->sb_offset = 0;
  265. rdev->size = 0;
  266. }
  267. }
  268. static int super_written(struct bio *bio, unsigned int bytes_done, int error)
  269. {
  270. mdk_rdev_t *rdev = bio->bi_private;
  271. if (bio->bi_size)
  272. return 1;
  273. if (error || !test_bit(BIO_UPTODATE, &bio->bi_flags))
  274. md_error(rdev->mddev, rdev);
  275. if (atomic_dec_and_test(&rdev->mddev->pending_writes))
  276. wake_up(&rdev->mddev->sb_wait);
  277. bio_put(bio);
  278. return 0;
  279. }
  280. void md_super_write(mddev_t *mddev, mdk_rdev_t *rdev,
  281. sector_t sector, int size, struct page *page)
  282. {
  283. /* write first size bytes of page to sector of rdev
  284. * Increment mddev->pending_writes before returning
  285. * and decrement it on completion, waking up sb_wait
  286. * if zero is reached.
  287. * If an error occurred, call md_error
  288. */
  289. struct bio *bio = bio_alloc(GFP_NOIO, 1);
  290. bio->bi_bdev = rdev->bdev;
  291. bio->bi_sector = sector;
  292. bio_add_page(bio, page, size, 0);
  293. bio->bi_private = rdev;
  294. bio->bi_end_io = super_written;
  295. atomic_inc(&mddev->pending_writes);
  296. submit_bio((1<<BIO_RW)|(1<<BIO_RW_SYNC), bio);
  297. }
  298. static int bi_complete(struct bio *bio, unsigned int bytes_done, int error)
  299. {
  300. if (bio->bi_size)
  301. return 1;
  302. complete((struct completion*)bio->bi_private);
  303. return 0;
  304. }
  305. int sync_page_io(struct block_device *bdev, sector_t sector, int size,
  306. struct page *page, int rw)
  307. {
  308. struct bio *bio = bio_alloc(GFP_NOIO, 1);
  309. struct completion event;
  310. int ret;
  311. rw |= (1 << BIO_RW_SYNC);
  312. bio->bi_bdev = bdev;
  313. bio->bi_sector = sector;
  314. bio_add_page(bio, page, size, 0);
  315. init_completion(&event);
  316. bio->bi_private = &event;
  317. bio->bi_end_io = bi_complete;
  318. submit_bio(rw, bio);
  319. wait_for_completion(&event);
  320. ret = test_bit(BIO_UPTODATE, &bio->bi_flags);
  321. bio_put(bio);
  322. return ret;
  323. }
  324. static int read_disk_sb(mdk_rdev_t * rdev)
  325. {
  326. char b[BDEVNAME_SIZE];
  327. if (!rdev->sb_page) {
  328. MD_BUG();
  329. return -EINVAL;
  330. }
  331. if (rdev->sb_loaded)
  332. return 0;
  333. if (!sync_page_io(rdev->bdev, rdev->sb_offset<<1, MD_SB_BYTES, rdev->sb_page, READ))
  334. goto fail;
  335. rdev->sb_loaded = 1;
  336. return 0;
  337. fail:
  338. printk(KERN_WARNING "md: disabled device %s, could not read superblock.\n",
  339. bdevname(rdev->bdev,b));
  340. return -EINVAL;
  341. }
  342. static int uuid_equal(mdp_super_t *sb1, mdp_super_t *sb2)
  343. {
  344. if ( (sb1->set_uuid0 == sb2->set_uuid0) &&
  345. (sb1->set_uuid1 == sb2->set_uuid1) &&
  346. (sb1->set_uuid2 == sb2->set_uuid2) &&
  347. (sb1->set_uuid3 == sb2->set_uuid3))
  348. return 1;
  349. return 0;
  350. }
  351. static int sb_equal(mdp_super_t *sb1, mdp_super_t *sb2)
  352. {
  353. int ret;
  354. mdp_super_t *tmp1, *tmp2;
  355. tmp1 = kmalloc(sizeof(*tmp1),GFP_KERNEL);
  356. tmp2 = kmalloc(sizeof(*tmp2),GFP_KERNEL);
  357. if (!tmp1 || !tmp2) {
  358. ret = 0;
  359. printk(KERN_INFO "md.c: sb1 is not equal to sb2!\n");
  360. goto abort;
  361. }
  362. *tmp1 = *sb1;
  363. *tmp2 = *sb2;
  364. /*
  365. * nr_disks is not constant
  366. */
  367. tmp1->nr_disks = 0;
  368. tmp2->nr_disks = 0;
  369. if (memcmp(tmp1, tmp2, MD_SB_GENERIC_CONSTANT_WORDS * 4))
  370. ret = 0;
  371. else
  372. ret = 1;
  373. abort:
  374. kfree(tmp1);
  375. kfree(tmp2);
  376. return ret;
  377. }
  378. static unsigned int calc_sb_csum(mdp_super_t * sb)
  379. {
  380. unsigned int disk_csum, csum;
  381. disk_csum = sb->sb_csum;
  382. sb->sb_csum = 0;
  383. csum = csum_partial((void *)sb, MD_SB_BYTES, 0);
  384. sb->sb_csum = disk_csum;
  385. return csum;
  386. }
  387. /*
  388. * Handle superblock details.
  389. * We want to be able to handle multiple superblock formats
  390. * so we have a common interface to them all, and an array of
  391. * different handlers.
  392. * We rely on user-space to write the initial superblock, and support
  393. * reading and updating of superblocks.
  394. * Interface methods are:
  395. * int load_super(mdk_rdev_t *dev, mdk_rdev_t *refdev, int minor_version)
  396. * loads and validates a superblock on dev.
  397. * if refdev != NULL, compare superblocks on both devices
  398. * Return:
  399. * 0 - dev has a superblock that is compatible with refdev
  400. * 1 - dev has a superblock that is compatible and newer than refdev
  401. * so dev should be used as the refdev in future
  402. * -EINVAL superblock incompatible or invalid
  403. * -othererror e.g. -EIO
  404. *
  405. * int validate_super(mddev_t *mddev, mdk_rdev_t *dev)
  406. * Verify that dev is acceptable into mddev.
  407. * The first time, mddev->raid_disks will be 0, and data from
  408. * dev should be merged in. Subsequent calls check that dev
  409. * is new enough. Return 0 or -EINVAL
  410. *
  411. * void sync_super(mddev_t *mddev, mdk_rdev_t *dev)
  412. * Update the superblock for rdev with data in mddev
  413. * This does not write to disc.
  414. *
  415. */
  416. struct super_type {
  417. char *name;
  418. struct module *owner;
  419. int (*load_super)(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version);
  420. int (*validate_super)(mddev_t *mddev, mdk_rdev_t *rdev);
  421. void (*sync_super)(mddev_t *mddev, mdk_rdev_t *rdev);
  422. };
  423. /*
  424. * load_super for 0.90.0
  425. */
  426. static int super_90_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
  427. {
  428. char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
  429. mdp_super_t *sb;
  430. int ret;
  431. sector_t sb_offset;
  432. /*
  433. * Calculate the position of the superblock,
  434. * it's at the end of the disk.
  435. *
  436. * It also happens to be a multiple of 4Kb.
  437. */
  438. sb_offset = calc_dev_sboffset(rdev->bdev);
  439. rdev->sb_offset = sb_offset;
  440. ret = read_disk_sb(rdev);
  441. if (ret) return ret;
  442. ret = -EINVAL;
  443. bdevname(rdev->bdev, b);
  444. sb = (mdp_super_t*)page_address(rdev->sb_page);
  445. if (sb->md_magic != MD_SB_MAGIC) {
  446. printk(KERN_ERR "md: invalid raid superblock magic on %s\n",
  447. b);
  448. goto abort;
  449. }
  450. if (sb->major_version != 0 ||
  451. sb->minor_version != 90) {
  452. printk(KERN_WARNING "Bad version number %d.%d on %s\n",
  453. sb->major_version, sb->minor_version,
  454. b);
  455. goto abort;
  456. }
  457. if (sb->raid_disks <= 0)
  458. goto abort;
  459. if (csum_fold(calc_sb_csum(sb)) != csum_fold(sb->sb_csum)) {
  460. printk(KERN_WARNING "md: invalid superblock checksum on %s\n",
  461. b);
  462. goto abort;
  463. }
  464. rdev->preferred_minor = sb->md_minor;
  465. rdev->data_offset = 0;
  466. if (sb->level == LEVEL_MULTIPATH)
  467. rdev->desc_nr = -1;
  468. else
  469. rdev->desc_nr = sb->this_disk.number;
  470. if (refdev == 0)
  471. ret = 1;
  472. else {
  473. __u64 ev1, ev2;
  474. mdp_super_t *refsb = (mdp_super_t*)page_address(refdev->sb_page);
  475. if (!uuid_equal(refsb, sb)) {
  476. printk(KERN_WARNING "md: %s has different UUID to %s\n",
  477. b, bdevname(refdev->bdev,b2));
  478. goto abort;
  479. }
  480. if (!sb_equal(refsb, sb)) {
  481. printk(KERN_WARNING "md: %s has same UUID"
  482. " but different superblock to %s\n",
  483. b, bdevname(refdev->bdev, b2));
  484. goto abort;
  485. }
  486. ev1 = md_event(sb);
  487. ev2 = md_event(refsb);
  488. if (ev1 > ev2)
  489. ret = 1;
  490. else
  491. ret = 0;
  492. }
  493. rdev->size = calc_dev_size(rdev, sb->chunk_size);
  494. abort:
  495. return ret;
  496. }
  497. /*
  498. * validate_super for 0.90.0
  499. */
  500. static int super_90_validate(mddev_t *mddev, mdk_rdev_t *rdev)
  501. {
  502. mdp_disk_t *desc;
  503. mdp_super_t *sb = (mdp_super_t *)page_address(rdev->sb_page);
  504. rdev->raid_disk = -1;
  505. rdev->in_sync = 0;
  506. if (mddev->raid_disks == 0) {
  507. mddev->major_version = 0;
  508. mddev->minor_version = sb->minor_version;
  509. mddev->patch_version = sb->patch_version;
  510. mddev->persistent = ! sb->not_persistent;
  511. mddev->chunk_size = sb->chunk_size;
  512. mddev->ctime = sb->ctime;
  513. mddev->utime = sb->utime;
  514. mddev->level = sb->level;
  515. mddev->layout = sb->layout;
  516. mddev->raid_disks = sb->raid_disks;
  517. mddev->size = sb->size;
  518. mddev->events = md_event(sb);
  519. if (sb->state & (1<<MD_SB_CLEAN))
  520. mddev->recovery_cp = MaxSector;
  521. else {
  522. if (sb->events_hi == sb->cp_events_hi &&
  523. sb->events_lo == sb->cp_events_lo) {
  524. mddev->recovery_cp = sb->recovery_cp;
  525. } else
  526. mddev->recovery_cp = 0;
  527. }
  528. memcpy(mddev->uuid+0, &sb->set_uuid0, 4);
  529. memcpy(mddev->uuid+4, &sb->set_uuid1, 4);
  530. memcpy(mddev->uuid+8, &sb->set_uuid2, 4);
  531. memcpy(mddev->uuid+12,&sb->set_uuid3, 4);
  532. mddev->max_disks = MD_SB_DISKS;
  533. if (sb->state & (1<<MD_SB_BITMAP_PRESENT) &&
  534. mddev->bitmap_file == NULL) {
  535. if (mddev->level != 1) {
  536. /* FIXME use a better test */
  537. printk(KERN_WARNING "md: bitmaps only support for raid1\n");
  538. return -EINVAL;
  539. }
  540. mddev->bitmap_offset = (MD_SB_BYTES >> 9);
  541. }
  542. } else if (mddev->pers == NULL) {
  543. /* Insist on good event counter while assembling */
  544. __u64 ev1 = md_event(sb);
  545. ++ev1;
  546. if (ev1 < mddev->events)
  547. return -EINVAL;
  548. } else if (mddev->bitmap) {
  549. /* if adding to array with a bitmap, then we can accept an
  550. * older device ... but not too old.
  551. */
  552. __u64 ev1 = md_event(sb);
  553. if (ev1 < mddev->bitmap->events_cleared)
  554. return 0;
  555. } else /* just a hot-add of a new device, leave raid_disk at -1 */
  556. return 0;
  557. if (mddev->level != LEVEL_MULTIPATH) {
  558. rdev->faulty = 0;
  559. desc = sb->disks + rdev->desc_nr;
  560. if (desc->state & (1<<MD_DISK_FAULTY))
  561. rdev->faulty = 1;
  562. else if (desc->state & (1<<MD_DISK_SYNC) &&
  563. desc->raid_disk < mddev->raid_disks) {
  564. rdev->in_sync = 1;
  565. rdev->raid_disk = desc->raid_disk;
  566. }
  567. } else /* MULTIPATH are always insync */
  568. rdev->in_sync = 1;
  569. return 0;
  570. }
  571. /*
  572. * sync_super for 0.90.0
  573. */
  574. static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
  575. {
  576. mdp_super_t *sb;
  577. struct list_head *tmp;
  578. mdk_rdev_t *rdev2;
  579. int next_spare = mddev->raid_disks;
  580. /* make rdev->sb match mddev data..
  581. *
  582. * 1/ zero out disks
  583. * 2/ Add info for each disk, keeping track of highest desc_nr (next_spare);
  584. * 3/ any empty disks < next_spare become removed
  585. *
  586. * disks[0] gets initialised to REMOVED because
  587. * we cannot be sure from other fields if it has
  588. * been initialised or not.
  589. */
  590. int i;
  591. int active=0, working=0,failed=0,spare=0,nr_disks=0;
  592. sb = (mdp_super_t*)page_address(rdev->sb_page);
  593. memset(sb, 0, sizeof(*sb));
  594. sb->md_magic = MD_SB_MAGIC;
  595. sb->major_version = mddev->major_version;
  596. sb->minor_version = mddev->minor_version;
  597. sb->patch_version = mddev->patch_version;
  598. sb->gvalid_words = 0; /* ignored */
  599. memcpy(&sb->set_uuid0, mddev->uuid+0, 4);
  600. memcpy(&sb->set_uuid1, mddev->uuid+4, 4);
  601. memcpy(&sb->set_uuid2, mddev->uuid+8, 4);
  602. memcpy(&sb->set_uuid3, mddev->uuid+12,4);
  603. sb->ctime = mddev->ctime;
  604. sb->level = mddev->level;
  605. sb->size = mddev->size;
  606. sb->raid_disks = mddev->raid_disks;
  607. sb->md_minor = mddev->md_minor;
  608. sb->not_persistent = !mddev->persistent;
  609. sb->utime = mddev->utime;
  610. sb->state = 0;
  611. sb->events_hi = (mddev->events>>32);
  612. sb->events_lo = (u32)mddev->events;
  613. if (mddev->in_sync)
  614. {
  615. sb->recovery_cp = mddev->recovery_cp;
  616. sb->cp_events_hi = (mddev->events>>32);
  617. sb->cp_events_lo = (u32)mddev->events;
  618. if (mddev->recovery_cp == MaxSector)
  619. sb->state = (1<< MD_SB_CLEAN);
  620. } else
  621. sb->recovery_cp = 0;
  622. sb->layout = mddev->layout;
  623. sb->chunk_size = mddev->chunk_size;
  624. if (mddev->bitmap && mddev->bitmap_file == NULL)
  625. sb->state |= (1<<MD_SB_BITMAP_PRESENT);
  626. sb->disks[0].state = (1<<MD_DISK_REMOVED);
  627. ITERATE_RDEV(mddev,rdev2,tmp) {
  628. mdp_disk_t *d;
  629. if (rdev2->raid_disk >= 0 && rdev2->in_sync && !rdev2->faulty)
  630. rdev2->desc_nr = rdev2->raid_disk;
  631. else
  632. rdev2->desc_nr = next_spare++;
  633. d = &sb->disks[rdev2->desc_nr];
  634. nr_disks++;
  635. d->number = rdev2->desc_nr;
  636. d->major = MAJOR(rdev2->bdev->bd_dev);
  637. d->minor = MINOR(rdev2->bdev->bd_dev);
  638. if (rdev2->raid_disk >= 0 && rdev->in_sync && !rdev2->faulty)
  639. d->raid_disk = rdev2->raid_disk;
  640. else
  641. d->raid_disk = rdev2->desc_nr; /* compatibility */
  642. if (rdev2->faulty) {
  643. d->state = (1<<MD_DISK_FAULTY);
  644. failed++;
  645. } else if (rdev2->in_sync) {
  646. d->state = (1<<MD_DISK_ACTIVE);
  647. d->state |= (1<<MD_DISK_SYNC);
  648. active++;
  649. working++;
  650. } else {
  651. d->state = 0;
  652. spare++;
  653. working++;
  654. }
  655. }
  656. /* now set the "removed" and "faulty" bits on any missing devices */
  657. for (i=0 ; i < mddev->raid_disks ; i++) {
  658. mdp_disk_t *d = &sb->disks[i];
  659. if (d->state == 0 && d->number == 0) {
  660. d->number = i;
  661. d->raid_disk = i;
  662. d->state = (1<<MD_DISK_REMOVED);
  663. d->state |= (1<<MD_DISK_FAULTY);
  664. failed++;
  665. }
  666. }
  667. sb->nr_disks = nr_disks;
  668. sb->active_disks = active;
  669. sb->working_disks = working;
  670. sb->failed_disks = failed;
  671. sb->spare_disks = spare;
  672. sb->this_disk = sb->disks[rdev->desc_nr];
  673. sb->sb_csum = calc_sb_csum(sb);
  674. }
  675. /*
  676. * version 1 superblock
  677. */
  678. static unsigned int calc_sb_1_csum(struct mdp_superblock_1 * sb)
  679. {
  680. unsigned int disk_csum, csum;
  681. unsigned long long newcsum;
  682. int size = 256 + le32_to_cpu(sb->max_dev)*2;
  683. unsigned int *isuper = (unsigned int*)sb;
  684. int i;
  685. disk_csum = sb->sb_csum;
  686. sb->sb_csum = 0;
  687. newcsum = 0;
  688. for (i=0; size>=4; size -= 4 )
  689. newcsum += le32_to_cpu(*isuper++);
  690. if (size == 2)
  691. newcsum += le16_to_cpu(*(unsigned short*) isuper);
  692. csum = (newcsum & 0xffffffff) + (newcsum >> 32);
  693. sb->sb_csum = disk_csum;
  694. return cpu_to_le32(csum);
  695. }
  696. static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
  697. {
  698. struct mdp_superblock_1 *sb;
  699. int ret;
  700. sector_t sb_offset;
  701. char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
  702. /*
  703. * Calculate the position of the superblock.
  704. * It is always aligned to a 4K boundary and
  705. * depeding on minor_version, it can be:
  706. * 0: At least 8K, but less than 12K, from end of device
  707. * 1: At start of device
  708. * 2: 4K from start of device.
  709. */
  710. switch(minor_version) {
  711. case 0:
  712. sb_offset = rdev->bdev->bd_inode->i_size >> 9;
  713. sb_offset -= 8*2;
  714. sb_offset &= ~(sector_t)(4*2-1);
  715. /* convert from sectors to K */
  716. sb_offset /= 2;
  717. break;
  718. case 1:
  719. sb_offset = 0;
  720. break;
  721. case 2:
  722. sb_offset = 4;
  723. break;
  724. default:
  725. return -EINVAL;
  726. }
  727. rdev->sb_offset = sb_offset;
  728. ret = read_disk_sb(rdev);
  729. if (ret) return ret;
  730. sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
  731. if (sb->magic != cpu_to_le32(MD_SB_MAGIC) ||
  732. sb->major_version != cpu_to_le32(1) ||
  733. le32_to_cpu(sb->max_dev) > (4096-256)/2 ||
  734. le64_to_cpu(sb->super_offset) != (rdev->sb_offset<<1) ||
  735. sb->feature_map != 0)
  736. return -EINVAL;
  737. if (calc_sb_1_csum(sb) != sb->sb_csum) {
  738. printk("md: invalid superblock checksum on %s\n",
  739. bdevname(rdev->bdev,b));
  740. return -EINVAL;
  741. }
  742. if (le64_to_cpu(sb->data_size) < 10) {
  743. printk("md: data_size too small on %s\n",
  744. bdevname(rdev->bdev,b));
  745. return -EINVAL;
  746. }
  747. rdev->preferred_minor = 0xffff;
  748. rdev->data_offset = le64_to_cpu(sb->data_offset);
  749. if (refdev == 0)
  750. return 1;
  751. else {
  752. __u64 ev1, ev2;
  753. struct mdp_superblock_1 *refsb =
  754. (struct mdp_superblock_1*)page_address(refdev->sb_page);
  755. if (memcmp(sb->set_uuid, refsb->set_uuid, 16) != 0 ||
  756. sb->level != refsb->level ||
  757. sb->layout != refsb->layout ||
  758. sb->chunksize != refsb->chunksize) {
  759. printk(KERN_WARNING "md: %s has strangely different"
  760. " superblock to %s\n",
  761. bdevname(rdev->bdev,b),
  762. bdevname(refdev->bdev,b2));
  763. return -EINVAL;
  764. }
  765. ev1 = le64_to_cpu(sb->events);
  766. ev2 = le64_to_cpu(refsb->events);
  767. if (ev1 > ev2)
  768. return 1;
  769. }
  770. if (minor_version)
  771. rdev->size = ((rdev->bdev->bd_inode->i_size>>9) - le64_to_cpu(sb->data_offset)) / 2;
  772. else
  773. rdev->size = rdev->sb_offset;
  774. if (rdev->size < le64_to_cpu(sb->data_size)/2)
  775. return -EINVAL;
  776. rdev->size = le64_to_cpu(sb->data_size)/2;
  777. if (le32_to_cpu(sb->chunksize))
  778. rdev->size &= ~((sector_t)le32_to_cpu(sb->chunksize)/2 - 1);
  779. return 0;
  780. }
  781. static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev)
  782. {
  783. struct mdp_superblock_1 *sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
  784. rdev->raid_disk = -1;
  785. rdev->in_sync = 0;
  786. if (mddev->raid_disks == 0) {
  787. mddev->major_version = 1;
  788. mddev->patch_version = 0;
  789. mddev->persistent = 1;
  790. mddev->chunk_size = le32_to_cpu(sb->chunksize) << 9;
  791. mddev->ctime = le64_to_cpu(sb->ctime) & ((1ULL << 32)-1);
  792. mddev->utime = le64_to_cpu(sb->utime) & ((1ULL << 32)-1);
  793. mddev->level = le32_to_cpu(sb->level);
  794. mddev->layout = le32_to_cpu(sb->layout);
  795. mddev->raid_disks = le32_to_cpu(sb->raid_disks);
  796. mddev->size = le64_to_cpu(sb->size)/2;
  797. mddev->events = le64_to_cpu(sb->events);
  798. mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
  799. memcpy(mddev->uuid, sb->set_uuid, 16);
  800. mddev->max_disks = (4096-256)/2;
  801. if ((le32_to_cpu(sb->feature_map) & 1) &&
  802. mddev->bitmap_file == NULL ) {
  803. if (mddev->level != 1) {
  804. printk(KERN_WARNING "md: bitmaps only supported for raid1\n");
  805. return -EINVAL;
  806. }
  807. mddev->bitmap_offset = (__s32)le32_to_cpu(sb->bitmap_offset);
  808. }
  809. } else if (mddev->pers == NULL) {
  810. /* Insist of good event counter while assembling */
  811. __u64 ev1 = le64_to_cpu(sb->events);
  812. ++ev1;
  813. if (ev1 < mddev->events)
  814. return -EINVAL;
  815. } else if (mddev->bitmap) {
  816. /* If adding to array with a bitmap, then we can accept an
  817. * older device, but not too old.
  818. */
  819. __u64 ev1 = le64_to_cpu(sb->events);
  820. if (ev1 < mddev->bitmap->events_cleared)
  821. return 0;
  822. } else /* just a hot-add of a new device, leave raid_disk at -1 */
  823. return 0;
  824. if (mddev->level != LEVEL_MULTIPATH) {
  825. int role;
  826. rdev->desc_nr = le32_to_cpu(sb->dev_number);
  827. role = le16_to_cpu(sb->dev_roles[rdev->desc_nr]);
  828. switch(role) {
  829. case 0xffff: /* spare */
  830. rdev->faulty = 0;
  831. break;
  832. case 0xfffe: /* faulty */
  833. rdev->faulty = 1;
  834. break;
  835. default:
  836. rdev->in_sync = 1;
  837. rdev->faulty = 0;
  838. rdev->raid_disk = role;
  839. break;
  840. }
  841. } else /* MULTIPATH are always insync */
  842. rdev->in_sync = 1;
  843. return 0;
  844. }
  845. static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
  846. {
  847. struct mdp_superblock_1 *sb;
  848. struct list_head *tmp;
  849. mdk_rdev_t *rdev2;
  850. int max_dev, i;
  851. /* make rdev->sb match mddev and rdev data. */
  852. sb = (struct mdp_superblock_1*)page_address(rdev->sb_page);
  853. sb->feature_map = 0;
  854. sb->pad0 = 0;
  855. memset(sb->pad1, 0, sizeof(sb->pad1));
  856. memset(sb->pad2, 0, sizeof(sb->pad2));
  857. memset(sb->pad3, 0, sizeof(sb->pad3));
  858. sb->utime = cpu_to_le64((__u64)mddev->utime);
  859. sb->events = cpu_to_le64(mddev->events);
  860. if (mddev->in_sync)
  861. sb->resync_offset = cpu_to_le64(mddev->recovery_cp);
  862. else
  863. sb->resync_offset = cpu_to_le64(0);
  864. if (mddev->bitmap && mddev->bitmap_file == NULL) {
  865. sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_offset);
  866. sb->feature_map = cpu_to_le32(1);
  867. }
  868. max_dev = 0;
  869. ITERATE_RDEV(mddev,rdev2,tmp)
  870. if (rdev2->desc_nr+1 > max_dev)
  871. max_dev = rdev2->desc_nr+1;
  872. sb->max_dev = cpu_to_le32(max_dev);
  873. for (i=0; i<max_dev;i++)
  874. sb->dev_roles[i] = cpu_to_le16(0xfffe);
  875. ITERATE_RDEV(mddev,rdev2,tmp) {
  876. i = rdev2->desc_nr;
  877. if (rdev2->faulty)
  878. sb->dev_roles[i] = cpu_to_le16(0xfffe);
  879. else if (rdev2->in_sync)
  880. sb->dev_roles[i] = cpu_to_le16(rdev2->raid_disk);
  881. else
  882. sb->dev_roles[i] = cpu_to_le16(0xffff);
  883. }
  884. sb->recovery_offset = cpu_to_le64(0); /* not supported yet */
  885. sb->sb_csum = calc_sb_1_csum(sb);
  886. }
  887. static struct super_type super_types[] = {
  888. [0] = {
  889. .name = "0.90.0",
  890. .owner = THIS_MODULE,
  891. .load_super = super_90_load,
  892. .validate_super = super_90_validate,
  893. .sync_super = super_90_sync,
  894. },
  895. [1] = {
  896. .name = "md-1",
  897. .owner = THIS_MODULE,
  898. .load_super = super_1_load,
  899. .validate_super = super_1_validate,
  900. .sync_super = super_1_sync,
  901. },
  902. };
  903. static mdk_rdev_t * match_dev_unit(mddev_t *mddev, mdk_rdev_t *dev)
  904. {
  905. struct list_head *tmp;
  906. mdk_rdev_t *rdev;
  907. ITERATE_RDEV(mddev,rdev,tmp)
  908. if (rdev->bdev->bd_contains == dev->bdev->bd_contains)
  909. return rdev;
  910. return NULL;
  911. }
  912. static int match_mddev_units(mddev_t *mddev1, mddev_t *mddev2)
  913. {
  914. struct list_head *tmp;
  915. mdk_rdev_t *rdev;
  916. ITERATE_RDEV(mddev1,rdev,tmp)
  917. if (match_dev_unit(mddev2, rdev))
  918. return 1;
  919. return 0;
  920. }
  921. static LIST_HEAD(pending_raid_disks);
  922. static int bind_rdev_to_array(mdk_rdev_t * rdev, mddev_t * mddev)
  923. {
  924. mdk_rdev_t *same_pdev;
  925. char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
  926. if (rdev->mddev) {
  927. MD_BUG();
  928. return -EINVAL;
  929. }
  930. same_pdev = match_dev_unit(mddev, rdev);
  931. if (same_pdev)
  932. printk(KERN_WARNING
  933. "%s: WARNING: %s appears to be on the same physical"
  934. " disk as %s. True\n protection against single-disk"
  935. " failure might be compromised.\n",
  936. mdname(mddev), bdevname(rdev->bdev,b),
  937. bdevname(same_pdev->bdev,b2));
  938. /* Verify rdev->desc_nr is unique.
  939. * If it is -1, assign a free number, else
  940. * check number is not in use
  941. */
  942. if (rdev->desc_nr < 0) {
  943. int choice = 0;
  944. if (mddev->pers) choice = mddev->raid_disks;
  945. while (find_rdev_nr(mddev, choice))
  946. choice++;
  947. rdev->desc_nr = choice;
  948. } else {
  949. if (find_rdev_nr(mddev, rdev->desc_nr))
  950. return -EBUSY;
  951. }
  952. list_add(&rdev->same_set, &mddev->disks);
  953. rdev->mddev = mddev;
  954. printk(KERN_INFO "md: bind<%s>\n", bdevname(rdev->bdev,b));
  955. return 0;
  956. }
  957. static void unbind_rdev_from_array(mdk_rdev_t * rdev)
  958. {
  959. char b[BDEVNAME_SIZE];
  960. if (!rdev->mddev) {
  961. MD_BUG();
  962. return;
  963. }
  964. list_del_init(&rdev->same_set);
  965. printk(KERN_INFO "md: unbind<%s>\n", bdevname(rdev->bdev,b));
  966. rdev->mddev = NULL;
  967. }
  968. /*
  969. * prevent the device from being mounted, repartitioned or
  970. * otherwise reused by a RAID array (or any other kernel
  971. * subsystem), by bd_claiming the device.
  972. */
  973. static int lock_rdev(mdk_rdev_t *rdev, dev_t dev)
  974. {
  975. int err = 0;
  976. struct block_device *bdev;
  977. char b[BDEVNAME_SIZE];
  978. bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE);
  979. if (IS_ERR(bdev)) {
  980. printk(KERN_ERR "md: could not open %s.\n",
  981. __bdevname(dev, b));
  982. return PTR_ERR(bdev);
  983. }
  984. err = bd_claim(bdev, rdev);
  985. if (err) {
  986. printk(KERN_ERR "md: could not bd_claim %s.\n",
  987. bdevname(bdev, b));
  988. blkdev_put(bdev);
  989. return err;
  990. }
  991. rdev->bdev = bdev;
  992. return err;
  993. }
  994. static void unlock_rdev(mdk_rdev_t *rdev)
  995. {
  996. struct block_device *bdev = rdev->bdev;
  997. rdev->bdev = NULL;
  998. if (!bdev)
  999. MD_BUG();
  1000. bd_release(bdev);
  1001. blkdev_put(bdev);
  1002. }
  1003. void md_autodetect_dev(dev_t dev);
  1004. static void export_rdev(mdk_rdev_t * rdev)
  1005. {
  1006. char b[BDEVNAME_SIZE];
  1007. printk(KERN_INFO "md: export_rdev(%s)\n",
  1008. bdevname(rdev->bdev,b));
  1009. if (rdev->mddev)
  1010. MD_BUG();
  1011. free_disk_sb(rdev);
  1012. list_del_init(&rdev->same_set);
  1013. #ifndef MODULE
  1014. md_autodetect_dev(rdev->bdev->bd_dev);
  1015. #endif
  1016. unlock_rdev(rdev);
  1017. kfree(rdev);
  1018. }
  1019. static void kick_rdev_from_array(mdk_rdev_t * rdev)
  1020. {
  1021. unbind_rdev_from_array(rdev);
  1022. export_rdev(rdev);
  1023. }
  1024. static void export_array(mddev_t *mddev)
  1025. {
  1026. struct list_head *tmp;
  1027. mdk_rdev_t *rdev;
  1028. ITERATE_RDEV(mddev,rdev,tmp) {
  1029. if (!rdev->mddev) {
  1030. MD_BUG();
  1031. continue;
  1032. }
  1033. kick_rdev_from_array(rdev);
  1034. }
  1035. if (!list_empty(&mddev->disks))
  1036. MD_BUG();
  1037. mddev->raid_disks = 0;
  1038. mddev->major_version = 0;
  1039. }
  1040. static void print_desc(mdp_disk_t *desc)
  1041. {
  1042. printk(" DISK<N:%d,(%d,%d),R:%d,S:%d>\n", desc->number,
  1043. desc->major,desc->minor,desc->raid_disk,desc->state);
  1044. }
  1045. static void print_sb(mdp_super_t *sb)
  1046. {
  1047. int i;
  1048. printk(KERN_INFO
  1049. "md: SB: (V:%d.%d.%d) ID:<%08x.%08x.%08x.%08x> CT:%08x\n",
  1050. sb->major_version, sb->minor_version, sb->patch_version,
  1051. sb->set_uuid0, sb->set_uuid1, sb->set_uuid2, sb->set_uuid3,
  1052. sb->ctime);
  1053. printk(KERN_INFO "md: L%d S%08d ND:%d RD:%d md%d LO:%d CS:%d\n",
  1054. sb->level, sb->size, sb->nr_disks, sb->raid_disks,
  1055. sb->md_minor, sb->layout, sb->chunk_size);
  1056. printk(KERN_INFO "md: UT:%08x ST:%d AD:%d WD:%d"
  1057. " FD:%d SD:%d CSUM:%08x E:%08lx\n",
  1058. sb->utime, sb->state, sb->active_disks, sb->working_disks,
  1059. sb->failed_disks, sb->spare_disks,
  1060. sb->sb_csum, (unsigned long)sb->events_lo);
  1061. printk(KERN_INFO);
  1062. for (i = 0; i < MD_SB_DISKS; i++) {
  1063. mdp_disk_t *desc;
  1064. desc = sb->disks + i;
  1065. if (desc->number || desc->major || desc->minor ||
  1066. desc->raid_disk || (desc->state && (desc->state != 4))) {
  1067. printk(" D %2d: ", i);
  1068. print_desc(desc);
  1069. }
  1070. }
  1071. printk(KERN_INFO "md: THIS: ");
  1072. print_desc(&sb->this_disk);
  1073. }
  1074. static void print_rdev(mdk_rdev_t *rdev)
  1075. {
  1076. char b[BDEVNAME_SIZE];
  1077. printk(KERN_INFO "md: rdev %s, SZ:%08llu F:%d S:%d DN:%u\n",
  1078. bdevname(rdev->bdev,b), (unsigned long long)rdev->size,
  1079. rdev->faulty, rdev->in_sync, rdev->desc_nr);
  1080. if (rdev->sb_loaded) {
  1081. printk(KERN_INFO "md: rdev superblock:\n");
  1082. print_sb((mdp_super_t*)page_address(rdev->sb_page));
  1083. } else
  1084. printk(KERN_INFO "md: no rdev superblock!\n");
  1085. }
  1086. void md_print_devices(void)
  1087. {
  1088. struct list_head *tmp, *tmp2;
  1089. mdk_rdev_t *rdev;
  1090. mddev_t *mddev;
  1091. char b[BDEVNAME_SIZE];
  1092. printk("\n");
  1093. printk("md: **********************************\n");
  1094. printk("md: * <COMPLETE RAID STATE PRINTOUT> *\n");
  1095. printk("md: **********************************\n");
  1096. ITERATE_MDDEV(mddev,tmp) {
  1097. if (mddev->bitmap)
  1098. bitmap_print_sb(mddev->bitmap);
  1099. else
  1100. printk("%s: ", mdname(mddev));
  1101. ITERATE_RDEV(mddev,rdev,tmp2)
  1102. printk("<%s>", bdevname(rdev->bdev,b));
  1103. printk("\n");
  1104. ITERATE_RDEV(mddev,rdev,tmp2)
  1105. print_rdev(rdev);
  1106. }
  1107. printk("md: **********************************\n");
  1108. printk("\n");
  1109. }
  1110. static void sync_sbs(mddev_t * mddev)
  1111. {
  1112. mdk_rdev_t *rdev;
  1113. struct list_head *tmp;
  1114. ITERATE_RDEV(mddev,rdev,tmp) {
  1115. super_types[mddev->major_version].
  1116. sync_super(mddev, rdev);
  1117. rdev->sb_loaded = 1;
  1118. }
  1119. }
  1120. static void md_update_sb(mddev_t * mddev)
  1121. {
  1122. int err;
  1123. struct list_head *tmp;
  1124. mdk_rdev_t *rdev;
  1125. int sync_req;
  1126. repeat:
  1127. spin_lock(&mddev->write_lock);
  1128. sync_req = mddev->in_sync;
  1129. mddev->utime = get_seconds();
  1130. mddev->events ++;
  1131. if (!mddev->events) {
  1132. /*
  1133. * oops, this 64-bit counter should never wrap.
  1134. * Either we are in around ~1 trillion A.C., assuming
  1135. * 1 reboot per second, or we have a bug:
  1136. */
  1137. MD_BUG();
  1138. mddev->events --;
  1139. }
  1140. mddev->sb_dirty = 2;
  1141. sync_sbs(mddev);
  1142. /*
  1143. * do not write anything to disk if using
  1144. * nonpersistent superblocks
  1145. */
  1146. if (!mddev->persistent) {
  1147. mddev->sb_dirty = 0;
  1148. spin_unlock(&mddev->write_lock);
  1149. wake_up(&mddev->sb_wait);
  1150. return;
  1151. }
  1152. spin_unlock(&mddev->write_lock);
  1153. dprintk(KERN_INFO
  1154. "md: updating %s RAID superblock on device (in sync %d)\n",
  1155. mdname(mddev),mddev->in_sync);
  1156. err = bitmap_update_sb(mddev->bitmap);
  1157. ITERATE_RDEV(mddev,rdev,tmp) {
  1158. char b[BDEVNAME_SIZE];
  1159. dprintk(KERN_INFO "md: ");
  1160. if (rdev->faulty)
  1161. dprintk("(skipping faulty ");
  1162. dprintk("%s ", bdevname(rdev->bdev,b));
  1163. if (!rdev->faulty) {
  1164. md_super_write(mddev,rdev,
  1165. rdev->sb_offset<<1, MD_SB_BYTES,
  1166. rdev->sb_page);
  1167. dprintk(KERN_INFO "(write) %s's sb offset: %llu\n",
  1168. bdevname(rdev->bdev,b),
  1169. (unsigned long long)rdev->sb_offset);
  1170. } else
  1171. dprintk(")\n");
  1172. if (mddev->level == LEVEL_MULTIPATH)
  1173. /* only need to write one superblock... */
  1174. break;
  1175. }
  1176. wait_event(mddev->sb_wait, atomic_read(&mddev->pending_writes)==0);
  1177. /* if there was a failure, sb_dirty was set to 1, and we re-write super */
  1178. spin_lock(&mddev->write_lock);
  1179. if (mddev->in_sync != sync_req|| mddev->sb_dirty == 1) {
  1180. /* have to write it out again */
  1181. spin_unlock(&mddev->write_lock);
  1182. goto repeat;
  1183. }
  1184. mddev->sb_dirty = 0;
  1185. spin_unlock(&mddev->write_lock);
  1186. wake_up(&mddev->sb_wait);
  1187. }
  1188. /*
  1189. * Import a device. If 'super_format' >= 0, then sanity check the superblock
  1190. *
  1191. * mark the device faulty if:
  1192. *
  1193. * - the device is nonexistent (zero size)
  1194. * - the device has no valid superblock
  1195. *
  1196. * a faulty rdev _never_ has rdev->sb set.
  1197. */
  1198. static mdk_rdev_t *md_import_device(dev_t newdev, int super_format, int super_minor)
  1199. {
  1200. char b[BDEVNAME_SIZE];
  1201. int err;
  1202. mdk_rdev_t *rdev;
  1203. sector_t size;
  1204. rdev = (mdk_rdev_t *) kmalloc(sizeof(*rdev), GFP_KERNEL);
  1205. if (!rdev) {
  1206. printk(KERN_ERR "md: could not alloc mem for new device!\n");
  1207. return ERR_PTR(-ENOMEM);
  1208. }
  1209. memset(rdev, 0, sizeof(*rdev));
  1210. if ((err = alloc_disk_sb(rdev)))
  1211. goto abort_free;
  1212. err = lock_rdev(rdev, newdev);
  1213. if (err)
  1214. goto abort_free;
  1215. rdev->desc_nr = -1;
  1216. rdev->faulty = 0;
  1217. rdev->in_sync = 0;
  1218. rdev->data_offset = 0;
  1219. atomic_set(&rdev->nr_pending, 0);
  1220. size = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
  1221. if (!size) {
  1222. printk(KERN_WARNING
  1223. "md: %s has zero or unknown size, marking faulty!\n",
  1224. bdevname(rdev->bdev,b));
  1225. err = -EINVAL;
  1226. goto abort_free;
  1227. }
  1228. if (super_format >= 0) {
  1229. err = super_types[super_format].
  1230. load_super(rdev, NULL, super_minor);
  1231. if (err == -EINVAL) {
  1232. printk(KERN_WARNING
  1233. "md: %s has invalid sb, not importing!\n",
  1234. bdevname(rdev->bdev,b));
  1235. goto abort_free;
  1236. }
  1237. if (err < 0) {
  1238. printk(KERN_WARNING
  1239. "md: could not read %s's sb, not importing!\n",
  1240. bdevname(rdev->bdev,b));
  1241. goto abort_free;
  1242. }
  1243. }
  1244. INIT_LIST_HEAD(&rdev->same_set);
  1245. return rdev;
  1246. abort_free:
  1247. if (rdev->sb_page) {
  1248. if (rdev->bdev)
  1249. unlock_rdev(rdev);
  1250. free_disk_sb(rdev);
  1251. }
  1252. kfree(rdev);
  1253. return ERR_PTR(err);
  1254. }
  1255. /*
  1256. * Check a full RAID array for plausibility
  1257. */
  1258. static void analyze_sbs(mddev_t * mddev)
  1259. {
  1260. int i;
  1261. struct list_head *tmp;
  1262. mdk_rdev_t *rdev, *freshest;
  1263. char b[BDEVNAME_SIZE];
  1264. freshest = NULL;
  1265. ITERATE_RDEV(mddev,rdev,tmp)
  1266. switch (super_types[mddev->major_version].
  1267. load_super(rdev, freshest, mddev->minor_version)) {
  1268. case 1:
  1269. freshest = rdev;
  1270. break;
  1271. case 0:
  1272. break;
  1273. default:
  1274. printk( KERN_ERR \
  1275. "md: fatal superblock inconsistency in %s"
  1276. " -- removing from array\n",
  1277. bdevname(rdev->bdev,b));
  1278. kick_rdev_from_array(rdev);
  1279. }
  1280. super_types[mddev->major_version].
  1281. validate_super(mddev, freshest);
  1282. i = 0;
  1283. ITERATE_RDEV(mddev,rdev,tmp) {
  1284. if (rdev != freshest)
  1285. if (super_types[mddev->major_version].
  1286. validate_super(mddev, rdev)) {
  1287. printk(KERN_WARNING "md: kicking non-fresh %s"
  1288. " from array!\n",
  1289. bdevname(rdev->bdev,b));
  1290. kick_rdev_from_array(rdev);
  1291. continue;
  1292. }
  1293. if (mddev->level == LEVEL_MULTIPATH) {
  1294. rdev->desc_nr = i++;
  1295. rdev->raid_disk = rdev->desc_nr;
  1296. rdev->in_sync = 1;
  1297. }
  1298. }
  1299. if (mddev->recovery_cp != MaxSector &&
  1300. mddev->level >= 1)
  1301. printk(KERN_ERR "md: %s: raid array is not clean"
  1302. " -- starting background reconstruction\n",
  1303. mdname(mddev));
  1304. }
  1305. int mdp_major = 0;
  1306. static struct kobject *md_probe(dev_t dev, int *part, void *data)
  1307. {
  1308. static DECLARE_MUTEX(disks_sem);
  1309. mddev_t *mddev = mddev_find(dev);
  1310. struct gendisk *disk;
  1311. int partitioned = (MAJOR(dev) != MD_MAJOR);
  1312. int shift = partitioned ? MdpMinorShift : 0;
  1313. int unit = MINOR(dev) >> shift;
  1314. if (!mddev)
  1315. return NULL;
  1316. down(&disks_sem);
  1317. if (mddev->gendisk) {
  1318. up(&disks_sem);
  1319. mddev_put(mddev);
  1320. return NULL;
  1321. }
  1322. disk = alloc_disk(1 << shift);
  1323. if (!disk) {
  1324. up(&disks_sem);
  1325. mddev_put(mddev);
  1326. return NULL;
  1327. }
  1328. disk->major = MAJOR(dev);
  1329. disk->first_minor = unit << shift;
  1330. if (partitioned) {
  1331. sprintf(disk->disk_name, "md_d%d", unit);
  1332. sprintf(disk->devfs_name, "md/d%d", unit);
  1333. } else {
  1334. sprintf(disk->disk_name, "md%d", unit);
  1335. sprintf(disk->devfs_name, "md/%d", unit);
  1336. }
  1337. disk->fops = &md_fops;
  1338. disk->private_data = mddev;
  1339. disk->queue = mddev->queue;
  1340. add_disk(disk);
  1341. mddev->gendisk = disk;
  1342. up(&disks_sem);
  1343. return NULL;
  1344. }
  1345. void md_wakeup_thread(mdk_thread_t *thread);
  1346. static void md_safemode_timeout(unsigned long data)
  1347. {
  1348. mddev_t *mddev = (mddev_t *) data;
  1349. mddev->safemode = 1;
  1350. md_wakeup_thread(mddev->thread);
  1351. }
  1352. static int do_md_run(mddev_t * mddev)
  1353. {
  1354. int pnum, err;
  1355. int chunk_size;
  1356. struct list_head *tmp;
  1357. mdk_rdev_t *rdev;
  1358. struct gendisk *disk;
  1359. char b[BDEVNAME_SIZE];
  1360. if (list_empty(&mddev->disks))
  1361. /* cannot run an array with no devices.. */
  1362. return -EINVAL;
  1363. if (mddev->pers)
  1364. return -EBUSY;
  1365. /*
  1366. * Analyze all RAID superblock(s)
  1367. */
  1368. if (!mddev->raid_disks)
  1369. analyze_sbs(mddev);
  1370. chunk_size = mddev->chunk_size;
  1371. pnum = level_to_pers(mddev->level);
  1372. if ((pnum != MULTIPATH) && (pnum != RAID1)) {
  1373. if (!chunk_size) {
  1374. /*
  1375. * 'default chunksize' in the old md code used to
  1376. * be PAGE_SIZE, baaad.
  1377. * we abort here to be on the safe side. We don't
  1378. * want to continue the bad practice.
  1379. */
  1380. printk(KERN_ERR
  1381. "no chunksize specified, see 'man raidtab'\n");
  1382. return -EINVAL;
  1383. }
  1384. if (chunk_size > MAX_CHUNK_SIZE) {
  1385. printk(KERN_ERR "too big chunk_size: %d > %d\n",
  1386. chunk_size, MAX_CHUNK_SIZE);
  1387. return -EINVAL;
  1388. }
  1389. /*
  1390. * chunk-size has to be a power of 2 and multiples of PAGE_SIZE
  1391. */
  1392. if ( (1 << ffz(~chunk_size)) != chunk_size) {
  1393. printk(KERN_ERR "chunk_size of %d not valid\n", chunk_size);
  1394. return -EINVAL;
  1395. }
  1396. if (chunk_size < PAGE_SIZE) {
  1397. printk(KERN_ERR "too small chunk_size: %d < %ld\n",
  1398. chunk_size, PAGE_SIZE);
  1399. return -EINVAL;
  1400. }
  1401. /* devices must have minimum size of one chunk */
  1402. ITERATE_RDEV(mddev,rdev,tmp) {
  1403. if (rdev->faulty)
  1404. continue;
  1405. if (rdev->size < chunk_size / 1024) {
  1406. printk(KERN_WARNING
  1407. "md: Dev %s smaller than chunk_size:"
  1408. " %lluk < %dk\n",
  1409. bdevname(rdev->bdev,b),
  1410. (unsigned long long)rdev->size,
  1411. chunk_size / 1024);
  1412. return -EINVAL;
  1413. }
  1414. }
  1415. }
  1416. #ifdef CONFIG_KMOD
  1417. if (!pers[pnum])
  1418. {
  1419. request_module("md-personality-%d", pnum);
  1420. }
  1421. #endif
  1422. /*
  1423. * Drop all container device buffers, from now on
  1424. * the only valid external interface is through the md
  1425. * device.
  1426. * Also find largest hardsector size
  1427. */
  1428. ITERATE_RDEV(mddev,rdev,tmp) {
  1429. if (rdev->faulty)
  1430. continue;
  1431. sync_blockdev(rdev->bdev);
  1432. invalidate_bdev(rdev->bdev, 0);
  1433. }
  1434. md_probe(mddev->unit, NULL, NULL);
  1435. disk = mddev->gendisk;
  1436. if (!disk)
  1437. return -ENOMEM;
  1438. spin_lock(&pers_lock);
  1439. if (!pers[pnum] || !try_module_get(pers[pnum]->owner)) {
  1440. spin_unlock(&pers_lock);
  1441. printk(KERN_WARNING "md: personality %d is not loaded!\n",
  1442. pnum);
  1443. return -EINVAL;
  1444. }
  1445. mddev->pers = pers[pnum];
  1446. spin_unlock(&pers_lock);
  1447. mddev->resync_max_sectors = mddev->size << 1; /* may be over-ridden by personality */
  1448. /* before we start the array running, initialise the bitmap */
  1449. err = bitmap_create(mddev);
  1450. if (err)
  1451. printk(KERN_ERR "%s: failed to create bitmap (%d)\n",
  1452. mdname(mddev), err);
  1453. else
  1454. err = mddev->pers->run(mddev);
  1455. if (err) {
  1456. printk(KERN_ERR "md: pers->run() failed ...\n");
  1457. module_put(mddev->pers->owner);
  1458. mddev->pers = NULL;
  1459. bitmap_destroy(mddev);
  1460. return err;
  1461. }
  1462. atomic_set(&mddev->writes_pending,0);
  1463. mddev->safemode = 0;
  1464. mddev->safemode_timer.function = md_safemode_timeout;
  1465. mddev->safemode_timer.data = (unsigned long) mddev;
  1466. mddev->safemode_delay = (20 * HZ)/1000 +1; /* 20 msec delay */
  1467. mddev->in_sync = 1;
  1468. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  1469. if (mddev->sb_dirty)
  1470. md_update_sb(mddev);
  1471. set_capacity(disk, mddev->array_size<<1);
  1472. /* If we call blk_queue_make_request here, it will
  1473. * re-initialise max_sectors etc which may have been
  1474. * refined inside -> run. So just set the bits we need to set.
  1475. * Most initialisation happended when we called
  1476. * blk_queue_make_request(..., md_fail_request)
  1477. * earlier.
  1478. */
  1479. mddev->queue->queuedata = mddev;
  1480. mddev->queue->make_request_fn = mddev->pers->make_request;
  1481. mddev->changed = 1;
  1482. return 0;
  1483. }
  1484. static int restart_array(mddev_t *mddev)
  1485. {
  1486. struct gendisk *disk = mddev->gendisk;
  1487. int err;
  1488. /*
  1489. * Complain if it has no devices
  1490. */
  1491. err = -ENXIO;
  1492. if (list_empty(&mddev->disks))
  1493. goto out;
  1494. if (mddev->pers) {
  1495. err = -EBUSY;
  1496. if (!mddev->ro)
  1497. goto out;
  1498. mddev->safemode = 0;
  1499. mddev->ro = 0;
  1500. set_disk_ro(disk, 0);
  1501. printk(KERN_INFO "md: %s switched to read-write mode.\n",
  1502. mdname(mddev));
  1503. /*
  1504. * Kick recovery or resync if necessary
  1505. */
  1506. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  1507. md_wakeup_thread(mddev->thread);
  1508. err = 0;
  1509. } else {
  1510. printk(KERN_ERR "md: %s has no personality assigned.\n",
  1511. mdname(mddev));
  1512. err = -EINVAL;
  1513. }
  1514. out:
  1515. return err;
  1516. }
  1517. static int do_md_stop(mddev_t * mddev, int ro)
  1518. {
  1519. int err = 0;
  1520. struct gendisk *disk = mddev->gendisk;
  1521. if (mddev->pers) {
  1522. if (atomic_read(&mddev->active)>2) {
  1523. printk("md: %s still in use.\n",mdname(mddev));
  1524. return -EBUSY;
  1525. }
  1526. if (mddev->sync_thread) {
  1527. set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  1528. md_unregister_thread(mddev->sync_thread);
  1529. mddev->sync_thread = NULL;
  1530. }
  1531. del_timer_sync(&mddev->safemode_timer);
  1532. invalidate_partition(disk, 0);
  1533. if (ro) {
  1534. err = -ENXIO;
  1535. if (mddev->ro)
  1536. goto out;
  1537. mddev->ro = 1;
  1538. } else {
  1539. bitmap_flush(mddev);
  1540. wait_event(mddev->sb_wait, atomic_read(&mddev->pending_writes)==0);
  1541. if (mddev->ro)
  1542. set_disk_ro(disk, 0);
  1543. blk_queue_make_request(mddev->queue, md_fail_request);
  1544. mddev->pers->stop(mddev);
  1545. module_put(mddev->pers->owner);
  1546. mddev->pers = NULL;
  1547. if (mddev->ro)
  1548. mddev->ro = 0;
  1549. }
  1550. if (!mddev->in_sync) {
  1551. /* mark array as shutdown cleanly */
  1552. mddev->in_sync = 1;
  1553. md_update_sb(mddev);
  1554. }
  1555. if (ro)
  1556. set_disk_ro(disk, 1);
  1557. }
  1558. bitmap_destroy(mddev);
  1559. if (mddev->bitmap_file) {
  1560. atomic_set(&mddev->bitmap_file->f_dentry->d_inode->i_writecount, 1);
  1561. fput(mddev->bitmap_file);
  1562. mddev->bitmap_file = NULL;
  1563. }
  1564. /*
  1565. * Free resources if final stop
  1566. */
  1567. if (!ro) {
  1568. struct gendisk *disk;
  1569. printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));
  1570. export_array(mddev);
  1571. mddev->array_size = 0;
  1572. disk = mddev->gendisk;
  1573. if (disk)
  1574. set_capacity(disk, 0);
  1575. mddev->changed = 1;
  1576. } else
  1577. printk(KERN_INFO "md: %s switched to read-only mode.\n",
  1578. mdname(mddev));
  1579. err = 0;
  1580. out:
  1581. return err;
  1582. }
  1583. static void autorun_array(mddev_t *mddev)
  1584. {
  1585. mdk_rdev_t *rdev;
  1586. struct list_head *tmp;
  1587. int err;
  1588. if (list_empty(&mddev->disks))
  1589. return;
  1590. printk(KERN_INFO "md: running: ");
  1591. ITERATE_RDEV(mddev,rdev,tmp) {
  1592. char b[BDEVNAME_SIZE];
  1593. printk("<%s>", bdevname(rdev->bdev,b));
  1594. }
  1595. printk("\n");
  1596. err = do_md_run (mddev);
  1597. if (err) {
  1598. printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
  1599. do_md_stop (mddev, 0);
  1600. }
  1601. }
  1602. /*
  1603. * lets try to run arrays based on all disks that have arrived
  1604. * until now. (those are in pending_raid_disks)
  1605. *
  1606. * the method: pick the first pending disk, collect all disks with
  1607. * the same UUID, remove all from the pending list and put them into
  1608. * the 'same_array' list. Then order this list based on superblock
  1609. * update time (freshest comes first), kick out 'old' disks and
  1610. * compare superblocks. If everything's fine then run it.
  1611. *
  1612. * If "unit" is allocated, then bump its reference count
  1613. */
  1614. static void autorun_devices(int part)
  1615. {
  1616. struct list_head candidates;
  1617. struct list_head *tmp;
  1618. mdk_rdev_t *rdev0, *rdev;
  1619. mddev_t *mddev;
  1620. char b[BDEVNAME_SIZE];
  1621. printk(KERN_INFO "md: autorun ...\n");
  1622. while (!list_empty(&pending_raid_disks)) {
  1623. dev_t dev;
  1624. rdev0 = list_entry(pending_raid_disks.next,
  1625. mdk_rdev_t, same_set);
  1626. printk(KERN_INFO "md: considering %s ...\n",
  1627. bdevname(rdev0->bdev,b));
  1628. INIT_LIST_HEAD(&candidates);
  1629. ITERATE_RDEV_PENDING(rdev,tmp)
  1630. if (super_90_load(rdev, rdev0, 0) >= 0) {
  1631. printk(KERN_INFO "md: adding %s ...\n",
  1632. bdevname(rdev->bdev,b));
  1633. list_move(&rdev->same_set, &candidates);
  1634. }
  1635. /*
  1636. * now we have a set of devices, with all of them having
  1637. * mostly sane superblocks. It's time to allocate the
  1638. * mddev.
  1639. */
  1640. if (rdev0->preferred_minor < 0 || rdev0->preferred_minor >= MAX_MD_DEVS) {
  1641. printk(KERN_INFO "md: unit number in %s is bad: %d\n",
  1642. bdevname(rdev0->bdev, b), rdev0->preferred_minor);
  1643. break;
  1644. }
  1645. if (part)
  1646. dev = MKDEV(mdp_major,
  1647. rdev0->preferred_minor << MdpMinorShift);
  1648. else
  1649. dev = MKDEV(MD_MAJOR, rdev0->preferred_minor);
  1650. md_probe(dev, NULL, NULL);
  1651. mddev = mddev_find(dev);
  1652. if (!mddev) {
  1653. printk(KERN_ERR
  1654. "md: cannot allocate memory for md drive.\n");
  1655. break;
  1656. }
  1657. if (mddev_lock(mddev))
  1658. printk(KERN_WARNING "md: %s locked, cannot run\n",
  1659. mdname(mddev));
  1660. else if (mddev->raid_disks || mddev->major_version
  1661. || !list_empty(&mddev->disks)) {
  1662. printk(KERN_WARNING
  1663. "md: %s already running, cannot run %s\n",
  1664. mdname(mddev), bdevname(rdev0->bdev,b));
  1665. mddev_unlock(mddev);
  1666. } else {
  1667. printk(KERN_INFO "md: created %s\n", mdname(mddev));
  1668. ITERATE_RDEV_GENERIC(candidates,rdev,tmp) {
  1669. list_del_init(&rdev->same_set);
  1670. if (bind_rdev_to_array(rdev, mddev))
  1671. export_rdev(rdev);
  1672. }
  1673. autorun_array(mddev);
  1674. mddev_unlock(mddev);
  1675. }
  1676. /* on success, candidates will be empty, on error
  1677. * it won't...
  1678. */
  1679. ITERATE_RDEV_GENERIC(candidates,rdev,tmp)
  1680. export_rdev(rdev);
  1681. mddev_put(mddev);
  1682. }
  1683. printk(KERN_INFO "md: ... autorun DONE.\n");
  1684. }
  1685. /*
  1686. * import RAID devices based on one partition
  1687. * if possible, the array gets run as well.
  1688. */
  1689. static int autostart_array(dev_t startdev)
  1690. {
  1691. char b[BDEVNAME_SIZE];
  1692. int err = -EINVAL, i;
  1693. mdp_super_t *sb = NULL;
  1694. mdk_rdev_t *start_rdev = NULL, *rdev;
  1695. start_rdev = md_import_device(startdev, 0, 0);
  1696. if (IS_ERR(start_rdev))
  1697. return err;
  1698. /* NOTE: this can only work for 0.90.0 superblocks */
  1699. sb = (mdp_super_t*)page_address(start_rdev->sb_page);
  1700. if (sb->major_version != 0 ||
  1701. sb->minor_version != 90 ) {
  1702. printk(KERN_WARNING "md: can only autostart 0.90.0 arrays\n");
  1703. export_rdev(start_rdev);
  1704. return err;
  1705. }
  1706. if (start_rdev->faulty) {
  1707. printk(KERN_WARNING
  1708. "md: can not autostart based on faulty %s!\n",
  1709. bdevname(start_rdev->bdev,b));
  1710. export_rdev(start_rdev);
  1711. return err;
  1712. }
  1713. list_add(&start_rdev->same_set, &pending_raid_disks);
  1714. for (i = 0; i < MD_SB_DISKS; i++) {
  1715. mdp_disk_t *desc = sb->disks + i;
  1716. dev_t dev = MKDEV(desc->major, desc->minor);
  1717. if (!dev)
  1718. continue;
  1719. if (dev == startdev)
  1720. continue;
  1721. if (MAJOR(dev) != desc->major || MINOR(dev) != desc->minor)
  1722. continue;
  1723. rdev = md_import_device(dev, 0, 0);
  1724. if (IS_ERR(rdev))
  1725. continue;
  1726. list_add(&rdev->same_set, &pending_raid_disks);
  1727. }
  1728. /*
  1729. * possibly return codes
  1730. */
  1731. autorun_devices(0);
  1732. return 0;
  1733. }
  1734. static int get_version(void __user * arg)
  1735. {
  1736. mdu_version_t ver;
  1737. ver.major = MD_MAJOR_VERSION;
  1738. ver.minor = MD_MINOR_VERSION;
  1739. ver.patchlevel = MD_PATCHLEVEL_VERSION;
  1740. if (copy_to_user(arg, &ver, sizeof(ver)))
  1741. return -EFAULT;
  1742. return 0;
  1743. }
  1744. static int get_array_info(mddev_t * mddev, void __user * arg)
  1745. {
  1746. mdu_array_info_t info;
  1747. int nr,working,active,failed,spare;
  1748. mdk_rdev_t *rdev;
  1749. struct list_head *tmp;
  1750. nr=working=active=failed=spare=0;
  1751. ITERATE_RDEV(mddev,rdev,tmp) {
  1752. nr++;
  1753. if (rdev->faulty)
  1754. failed++;
  1755. else {
  1756. working++;
  1757. if (rdev->in_sync)
  1758. active++;
  1759. else
  1760. spare++;
  1761. }
  1762. }
  1763. info.major_version = mddev->major_version;
  1764. info.minor_version = mddev->minor_version;
  1765. info.patch_version = MD_PATCHLEVEL_VERSION;
  1766. info.ctime = mddev->ctime;
  1767. info.level = mddev->level;
  1768. info.size = mddev->size;
  1769. info.nr_disks = nr;
  1770. info.raid_disks = mddev->raid_disks;
  1771. info.md_minor = mddev->md_minor;
  1772. info.not_persistent= !mddev->persistent;
  1773. info.utime = mddev->utime;
  1774. info.state = 0;
  1775. if (mddev->in_sync)
  1776. info.state = (1<<MD_SB_CLEAN);
  1777. info.active_disks = active;
  1778. info.working_disks = working;
  1779. info.failed_disks = failed;
  1780. info.spare_disks = spare;
  1781. info.layout = mddev->layout;
  1782. info.chunk_size = mddev->chunk_size;
  1783. if (copy_to_user(arg, &info, sizeof(info)))
  1784. return -EFAULT;
  1785. return 0;
  1786. }
  1787. static int get_bitmap_file(mddev_t * mddev, void * arg)
  1788. {
  1789. mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */
  1790. char *ptr, *buf = NULL;
  1791. int err = -ENOMEM;
  1792. file = kmalloc(sizeof(*file), GFP_KERNEL);
  1793. if (!file)
  1794. goto out;
  1795. /* bitmap disabled, zero the first byte and copy out */
  1796. if (!mddev->bitmap || !mddev->bitmap->file) {
  1797. file->pathname[0] = '\0';
  1798. goto copy_out;
  1799. }
  1800. buf = kmalloc(sizeof(file->pathname), GFP_KERNEL);
  1801. if (!buf)
  1802. goto out;
  1803. ptr = file_path(mddev->bitmap->file, buf, sizeof(file->pathname));
  1804. if (!ptr)
  1805. goto out;
  1806. strcpy(file->pathname, ptr);
  1807. copy_out:
  1808. err = 0;
  1809. if (copy_to_user(arg, file, sizeof(*file)))
  1810. err = -EFAULT;
  1811. out:
  1812. kfree(buf);
  1813. kfree(file);
  1814. return err;
  1815. }
  1816. static int get_disk_info(mddev_t * mddev, void __user * arg)
  1817. {
  1818. mdu_disk_info_t info;
  1819. unsigned int nr;
  1820. mdk_rdev_t *rdev;
  1821. if (copy_from_user(&info, arg, sizeof(info)))
  1822. return -EFAULT;
  1823. nr = info.number;
  1824. rdev = find_rdev_nr(mddev, nr);
  1825. if (rdev) {
  1826. info.major = MAJOR(rdev->bdev->bd_dev);
  1827. info.minor = MINOR(rdev->bdev->bd_dev);
  1828. info.raid_disk = rdev->raid_disk;
  1829. info.state = 0;
  1830. if (rdev->faulty)
  1831. info.state |= (1<<MD_DISK_FAULTY);
  1832. else if (rdev->in_sync) {
  1833. info.state |= (1<<MD_DISK_ACTIVE);
  1834. info.state |= (1<<MD_DISK_SYNC);
  1835. }
  1836. } else {
  1837. info.major = info.minor = 0;
  1838. info.raid_disk = -1;
  1839. info.state = (1<<MD_DISK_REMOVED);
  1840. }
  1841. if (copy_to_user(arg, &info, sizeof(info)))
  1842. return -EFAULT;
  1843. return 0;
  1844. }
  1845. static int add_new_disk(mddev_t * mddev, mdu_disk_info_t *info)
  1846. {
  1847. char b[BDEVNAME_SIZE], b2[BDEVNAME_SIZE];
  1848. mdk_rdev_t *rdev;
  1849. dev_t dev = MKDEV(info->major,info->minor);
  1850. if (info->major != MAJOR(dev) || info->minor != MINOR(dev))
  1851. return -EOVERFLOW;
  1852. if (!mddev->raid_disks) {
  1853. int err;
  1854. /* expecting a device which has a superblock */
  1855. rdev = md_import_device(dev, mddev->major_version, mddev->minor_version);
  1856. if (IS_ERR(rdev)) {
  1857. printk(KERN_WARNING
  1858. "md: md_import_device returned %ld\n",
  1859. PTR_ERR(rdev));
  1860. return PTR_ERR(rdev);
  1861. }
  1862. if (!list_empty(&mddev->disks)) {
  1863. mdk_rdev_t *rdev0 = list_entry(mddev->disks.next,
  1864. mdk_rdev_t, same_set);
  1865. int err = super_types[mddev->major_version]
  1866. .load_super(rdev, rdev0, mddev->minor_version);
  1867. if (err < 0) {
  1868. printk(KERN_WARNING
  1869. "md: %s has different UUID to %s\n",
  1870. bdevname(rdev->bdev,b),
  1871. bdevname(rdev0->bdev,b2));
  1872. export_rdev(rdev);
  1873. return -EINVAL;
  1874. }
  1875. }
  1876. err = bind_rdev_to_array(rdev, mddev);
  1877. if (err)
  1878. export_rdev(rdev);
  1879. return err;
  1880. }
  1881. /*
  1882. * add_new_disk can be used once the array is assembled
  1883. * to add "hot spares". They must already have a superblock
  1884. * written
  1885. */
  1886. if (mddev->pers) {
  1887. int err;
  1888. if (!mddev->pers->hot_add_disk) {
  1889. printk(KERN_WARNING
  1890. "%s: personality does not support diskops!\n",
  1891. mdname(mddev));
  1892. return -EINVAL;
  1893. }
  1894. rdev = md_import_device(dev, mddev->major_version,
  1895. mddev->minor_version);
  1896. if (IS_ERR(rdev)) {
  1897. printk(KERN_WARNING
  1898. "md: md_import_device returned %ld\n",
  1899. PTR_ERR(rdev));
  1900. return PTR_ERR(rdev);
  1901. }
  1902. /* set save_raid_disk if appropriate */
  1903. if (!mddev->persistent) {
  1904. if (info->state & (1<<MD_DISK_SYNC) &&
  1905. info->raid_disk < mddev->raid_disks)
  1906. rdev->raid_disk = info->raid_disk;
  1907. else
  1908. rdev->raid_disk = -1;
  1909. } else
  1910. super_types[mddev->major_version].
  1911. validate_super(mddev, rdev);
  1912. rdev->saved_raid_disk = rdev->raid_disk;
  1913. rdev->in_sync = 0; /* just to be sure */
  1914. rdev->raid_disk = -1;
  1915. err = bind_rdev_to_array(rdev, mddev);
  1916. if (err)
  1917. export_rdev(rdev);
  1918. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  1919. if (mddev->thread)
  1920. md_wakeup_thread(mddev->thread);
  1921. return err;
  1922. }
  1923. /* otherwise, add_new_disk is only allowed
  1924. * for major_version==0 superblocks
  1925. */
  1926. if (mddev->major_version != 0) {
  1927. printk(KERN_WARNING "%s: ADD_NEW_DISK not supported\n",
  1928. mdname(mddev));
  1929. return -EINVAL;
  1930. }
  1931. if (!(info->state & (1<<MD_DISK_FAULTY))) {
  1932. int err;
  1933. rdev = md_import_device (dev, -1, 0);
  1934. if (IS_ERR(rdev)) {
  1935. printk(KERN_WARNING
  1936. "md: error, md_import_device() returned %ld\n",
  1937. PTR_ERR(rdev));
  1938. return PTR_ERR(rdev);
  1939. }
  1940. rdev->desc_nr = info->number;
  1941. if (info->raid_disk < mddev->raid_disks)
  1942. rdev->raid_disk = info->raid_disk;
  1943. else
  1944. rdev->raid_disk = -1;
  1945. rdev->faulty = 0;
  1946. if (rdev->raid_disk < mddev->raid_disks)
  1947. rdev->in_sync = (info->state & (1<<MD_DISK_SYNC));
  1948. else
  1949. rdev->in_sync = 0;
  1950. err = bind_rdev_to_array(rdev, mddev);
  1951. if (err) {
  1952. export_rdev(rdev);
  1953. return err;
  1954. }
  1955. if (!mddev->persistent) {
  1956. printk(KERN_INFO "md: nonpersistent superblock ...\n");
  1957. rdev->sb_offset = rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
  1958. } else
  1959. rdev->sb_offset = calc_dev_sboffset(rdev->bdev);
  1960. rdev->size = calc_dev_size(rdev, mddev->chunk_size);
  1961. if (!mddev->size || (mddev->size > rdev->size))
  1962. mddev->size = rdev->size;
  1963. }
  1964. return 0;
  1965. }
  1966. static int hot_remove_disk(mddev_t * mddev, dev_t dev)
  1967. {
  1968. char b[BDEVNAME_SIZE];
  1969. mdk_rdev_t *rdev;
  1970. if (!mddev->pers)
  1971. return -ENODEV;
  1972. rdev = find_rdev(mddev, dev);
  1973. if (!rdev)
  1974. return -ENXIO;
  1975. if (rdev->raid_disk >= 0)
  1976. goto busy;
  1977. kick_rdev_from_array(rdev);
  1978. md_update_sb(mddev);
  1979. return 0;
  1980. busy:
  1981. printk(KERN_WARNING "md: cannot remove active disk %s from %s ... \n",
  1982. bdevname(rdev->bdev,b), mdname(mddev));
  1983. return -EBUSY;
  1984. }
  1985. static int hot_add_disk(mddev_t * mddev, dev_t dev)
  1986. {
  1987. char b[BDEVNAME_SIZE];
  1988. int err;
  1989. unsigned int size;
  1990. mdk_rdev_t *rdev;
  1991. if (!mddev->pers)
  1992. return -ENODEV;
  1993. if (mddev->major_version != 0) {
  1994. printk(KERN_WARNING "%s: HOT_ADD may only be used with"
  1995. " version-0 superblocks.\n",
  1996. mdname(mddev));
  1997. return -EINVAL;
  1998. }
  1999. if (!mddev->pers->hot_add_disk) {
  2000. printk(KERN_WARNING
  2001. "%s: personality does not support diskops!\n",
  2002. mdname(mddev));
  2003. return -EINVAL;
  2004. }
  2005. rdev = md_import_device (dev, -1, 0);
  2006. if (IS_ERR(rdev)) {
  2007. printk(KERN_WARNING
  2008. "md: error, md_import_device() returned %ld\n",
  2009. PTR_ERR(rdev));
  2010. return -EINVAL;
  2011. }
  2012. if (mddev->persistent)
  2013. rdev->sb_offset = calc_dev_sboffset(rdev->bdev);
  2014. else
  2015. rdev->sb_offset =
  2016. rdev->bdev->bd_inode->i_size >> BLOCK_SIZE_BITS;
  2017. size = calc_dev_size(rdev, mddev->chunk_size);
  2018. rdev->size = size;
  2019. if (size < mddev->size) {
  2020. printk(KERN_WARNING
  2021. "%s: disk size %llu blocks < array size %llu\n",
  2022. mdname(mddev), (unsigned long long)size,
  2023. (unsigned long long)mddev->size);
  2024. err = -ENOSPC;
  2025. goto abort_export;
  2026. }
  2027. if (rdev->faulty) {
  2028. printk(KERN_WARNING
  2029. "md: can not hot-add faulty %s disk to %s!\n",
  2030. bdevname(rdev->bdev,b), mdname(mddev));
  2031. err = -EINVAL;
  2032. goto abort_export;
  2033. }
  2034. rdev->in_sync = 0;
  2035. rdev->desc_nr = -1;
  2036. bind_rdev_to_array(rdev, mddev);
  2037. /*
  2038. * The rest should better be atomic, we can have disk failures
  2039. * noticed in interrupt contexts ...
  2040. */
  2041. if (rdev->desc_nr == mddev->max_disks) {
  2042. printk(KERN_WARNING "%s: can not hot-add to full array!\n",
  2043. mdname(mddev));
  2044. err = -EBUSY;
  2045. goto abort_unbind_export;
  2046. }
  2047. rdev->raid_disk = -1;
  2048. md_update_sb(mddev);
  2049. /*
  2050. * Kick recovery, maybe this spare has to be added to the
  2051. * array immediately.
  2052. */
  2053. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  2054. md_wakeup_thread(mddev->thread);
  2055. return 0;
  2056. abort_unbind_export:
  2057. unbind_rdev_from_array(rdev);
  2058. abort_export:
  2059. export_rdev(rdev);
  2060. return err;
  2061. }
  2062. /* similar to deny_write_access, but accounts for our holding a reference
  2063. * to the file ourselves */
  2064. static int deny_bitmap_write_access(struct file * file)
  2065. {
  2066. struct inode *inode = file->f_mapping->host;
  2067. spin_lock(&inode->i_lock);
  2068. if (atomic_read(&inode->i_writecount) > 1) {
  2069. spin_unlock(&inode->i_lock);
  2070. return -ETXTBSY;
  2071. }
  2072. atomic_set(&inode->i_writecount, -1);
  2073. spin_unlock(&inode->i_lock);
  2074. return 0;
  2075. }
  2076. static int set_bitmap_file(mddev_t *mddev, int fd)
  2077. {
  2078. int err;
  2079. if (mddev->pers)
  2080. return -EBUSY;
  2081. mddev->bitmap_file = fget(fd);
  2082. if (mddev->bitmap_file == NULL) {
  2083. printk(KERN_ERR "%s: error: failed to get bitmap file\n",
  2084. mdname(mddev));
  2085. return -EBADF;
  2086. }
  2087. err = deny_bitmap_write_access(mddev->bitmap_file);
  2088. if (err) {
  2089. printk(KERN_ERR "%s: error: bitmap file is already in use\n",
  2090. mdname(mddev));
  2091. fput(mddev->bitmap_file);
  2092. mddev->bitmap_file = NULL;
  2093. } else
  2094. mddev->bitmap_offset = 0; /* file overrides offset */
  2095. return err;
  2096. }
  2097. /*
  2098. * set_array_info is used two different ways
  2099. * The original usage is when creating a new array.
  2100. * In this usage, raid_disks is > 0 and it together with
  2101. * level, size, not_persistent,layout,chunksize determine the
  2102. * shape of the array.
  2103. * This will always create an array with a type-0.90.0 superblock.
  2104. * The newer usage is when assembling an array.
  2105. * In this case raid_disks will be 0, and the major_version field is
  2106. * use to determine which style super-blocks are to be found on the devices.
  2107. * The minor and patch _version numbers are also kept incase the
  2108. * super_block handler wishes to interpret them.
  2109. */
  2110. static int set_array_info(mddev_t * mddev, mdu_array_info_t *info)
  2111. {
  2112. if (info->raid_disks == 0) {
  2113. /* just setting version number for superblock loading */
  2114. if (info->major_version < 0 ||
  2115. info->major_version >= sizeof(super_types)/sizeof(super_types[0]) ||
  2116. super_types[info->major_version].name == NULL) {
  2117. /* maybe try to auto-load a module? */
  2118. printk(KERN_INFO
  2119. "md: superblock version %d not known\n",
  2120. info->major_version);
  2121. return -EINVAL;
  2122. }
  2123. mddev->major_version = info->major_version;
  2124. mddev->minor_version = info->minor_version;
  2125. mddev->patch_version = info->patch_version;
  2126. return 0;
  2127. }
  2128. mddev->major_version = MD_MAJOR_VERSION;
  2129. mddev->minor_version = MD_MINOR_VERSION;
  2130. mddev->patch_version = MD_PATCHLEVEL_VERSION;
  2131. mddev->ctime = get_seconds();
  2132. mddev->level = info->level;
  2133. mddev->size = info->size;
  2134. mddev->raid_disks = info->raid_disks;
  2135. /* don't set md_minor, it is determined by which /dev/md* was
  2136. * openned
  2137. */
  2138. if (info->state & (1<<MD_SB_CLEAN))
  2139. mddev->recovery_cp = MaxSector;
  2140. else
  2141. mddev->recovery_cp = 0;
  2142. mddev->persistent = ! info->not_persistent;
  2143. mddev->layout = info->layout;
  2144. mddev->chunk_size = info->chunk_size;
  2145. mddev->max_disks = MD_SB_DISKS;
  2146. mddev->sb_dirty = 1;
  2147. /*
  2148. * Generate a 128 bit UUID
  2149. */
  2150. get_random_bytes(mddev->uuid, 16);
  2151. return 0;
  2152. }
  2153. /*
  2154. * update_array_info is used to change the configuration of an
  2155. * on-line array.
  2156. * The version, ctime,level,size,raid_disks,not_persistent, layout,chunk_size
  2157. * fields in the info are checked against the array.
  2158. * Any differences that cannot be handled will cause an error.
  2159. * Normally, only one change can be managed at a time.
  2160. */
  2161. static int update_array_info(mddev_t *mddev, mdu_array_info_t *info)
  2162. {
  2163. int rv = 0;
  2164. int cnt = 0;
  2165. if (mddev->major_version != info->major_version ||
  2166. mddev->minor_version != info->minor_version ||
  2167. /* mddev->patch_version != info->patch_version || */
  2168. mddev->ctime != info->ctime ||
  2169. mddev->level != info->level ||
  2170. /* mddev->layout != info->layout || */
  2171. !mddev->persistent != info->not_persistent||
  2172. mddev->chunk_size != info->chunk_size )
  2173. return -EINVAL;
  2174. /* Check there is only one change */
  2175. if (mddev->size != info->size) cnt++;
  2176. if (mddev->raid_disks != info->raid_disks) cnt++;
  2177. if (mddev->layout != info->layout) cnt++;
  2178. if (cnt == 0) return 0;
  2179. if (cnt > 1) return -EINVAL;
  2180. if (mddev->layout != info->layout) {
  2181. /* Change layout
  2182. * we don't need to do anything at the md level, the
  2183. * personality will take care of it all.
  2184. */
  2185. if (mddev->pers->reconfig == NULL)
  2186. return -EINVAL;
  2187. else
  2188. return mddev->pers->reconfig(mddev, info->layout, -1);
  2189. }
  2190. if (mddev->size != info->size) {
  2191. mdk_rdev_t * rdev;
  2192. struct list_head *tmp;
  2193. if (mddev->pers->resize == NULL)
  2194. return -EINVAL;
  2195. /* The "size" is the amount of each device that is used.
  2196. * This can only make sense for arrays with redundancy.
  2197. * linear and raid0 always use whatever space is available
  2198. * We can only consider changing the size if no resync
  2199. * or reconstruction is happening, and if the new size
  2200. * is acceptable. It must fit before the sb_offset or,
  2201. * if that is <data_offset, it must fit before the
  2202. * size of each device.
  2203. * If size is zero, we find the largest size that fits.
  2204. */
  2205. if (mddev->sync_thread)
  2206. return -EBUSY;
  2207. ITERATE_RDEV(mddev,rdev,tmp) {
  2208. sector_t avail;
  2209. int fit = (info->size == 0);
  2210. if (rdev->sb_offset > rdev->data_offset)
  2211. avail = (rdev->sb_offset*2) - rdev->data_offset;
  2212. else
  2213. avail = get_capacity(rdev->bdev->bd_disk)
  2214. - rdev->data_offset;
  2215. if (fit && (info->size == 0 || info->size > avail/2))
  2216. info->size = avail/2;
  2217. if (avail < ((sector_t)info->size << 1))
  2218. return -ENOSPC;
  2219. }
  2220. rv = mddev->pers->resize(mddev, (sector_t)info->size *2);
  2221. if (!rv) {
  2222. struct block_device *bdev;
  2223. bdev = bdget_disk(mddev->gendisk, 0);
  2224. if (bdev) {
  2225. down(&bdev->bd_inode->i_sem);
  2226. i_size_write(bdev->bd_inode, mddev->array_size << 10);
  2227. up(&bdev->bd_inode->i_sem);
  2228. bdput(bdev);
  2229. }
  2230. }
  2231. }
  2232. if (mddev->raid_disks != info->raid_disks) {
  2233. /* change the number of raid disks */
  2234. if (mddev->pers->reshape == NULL)
  2235. return -EINVAL;
  2236. if (info->raid_disks <= 0 ||
  2237. info->raid_disks >= mddev->max_disks)
  2238. return -EINVAL;
  2239. if (mddev->sync_thread)
  2240. return -EBUSY;
  2241. rv = mddev->pers->reshape(mddev, info->raid_disks);
  2242. if (!rv) {
  2243. struct block_device *bdev;
  2244. bdev = bdget_disk(mddev->gendisk, 0);
  2245. if (bdev) {
  2246. down(&bdev->bd_inode->i_sem);
  2247. i_size_write(bdev->bd_inode, mddev->array_size << 10);
  2248. up(&bdev->bd_inode->i_sem);
  2249. bdput(bdev);
  2250. }
  2251. }
  2252. }
  2253. md_update_sb(mddev);
  2254. return rv;
  2255. }
  2256. static int set_disk_faulty(mddev_t *mddev, dev_t dev)
  2257. {
  2258. mdk_rdev_t *rdev;
  2259. if (mddev->pers == NULL)
  2260. return -ENODEV;
  2261. rdev = find_rdev(mddev, dev);
  2262. if (!rdev)
  2263. return -ENODEV;
  2264. md_error(mddev, rdev);
  2265. return 0;
  2266. }
  2267. static int md_ioctl(struct inode *inode, struct file *file,
  2268. unsigned int cmd, unsigned long arg)
  2269. {
  2270. int err = 0;
  2271. void __user *argp = (void __user *)arg;
  2272. struct hd_geometry __user *loc = argp;
  2273. mddev_t *mddev = NULL;
  2274. if (!capable(CAP_SYS_ADMIN))
  2275. return -EACCES;
  2276. /*
  2277. * Commands dealing with the RAID driver but not any
  2278. * particular array:
  2279. */
  2280. switch (cmd)
  2281. {
  2282. case RAID_VERSION:
  2283. err = get_version(argp);
  2284. goto done;
  2285. case PRINT_RAID_DEBUG:
  2286. err = 0;
  2287. md_print_devices();
  2288. goto done;
  2289. #ifndef MODULE
  2290. case RAID_AUTORUN:
  2291. err = 0;
  2292. autostart_arrays(arg);
  2293. goto done;
  2294. #endif
  2295. default:;
  2296. }
  2297. /*
  2298. * Commands creating/starting a new array:
  2299. */
  2300. mddev = inode->i_bdev->bd_disk->private_data;
  2301. if (!mddev) {
  2302. BUG();
  2303. goto abort;
  2304. }
  2305. if (cmd == START_ARRAY) {
  2306. /* START_ARRAY doesn't need to lock the array as autostart_array
  2307. * does the locking, and it could even be a different array
  2308. */
  2309. static int cnt = 3;
  2310. if (cnt > 0 ) {
  2311. printk(KERN_WARNING
  2312. "md: %s(pid %d) used deprecated START_ARRAY ioctl. "
  2313. "This will not be supported beyond 2.6\n",
  2314. current->comm, current->pid);
  2315. cnt--;
  2316. }
  2317. err = autostart_array(new_decode_dev(arg));
  2318. if (err) {
  2319. printk(KERN_WARNING "md: autostart failed!\n");
  2320. goto abort;
  2321. }
  2322. goto done;
  2323. }
  2324. err = mddev_lock(mddev);
  2325. if (err) {
  2326. printk(KERN_INFO
  2327. "md: ioctl lock interrupted, reason %d, cmd %d\n",
  2328. err, cmd);
  2329. goto abort;
  2330. }
  2331. switch (cmd)
  2332. {
  2333. case SET_ARRAY_INFO:
  2334. {
  2335. mdu_array_info_t info;
  2336. if (!arg)
  2337. memset(&info, 0, sizeof(info));
  2338. else if (copy_from_user(&info, argp, sizeof(info))) {
  2339. err = -EFAULT;
  2340. goto abort_unlock;
  2341. }
  2342. if (mddev->pers) {
  2343. err = update_array_info(mddev, &info);
  2344. if (err) {
  2345. printk(KERN_WARNING "md: couldn't update"
  2346. " array info. %d\n", err);
  2347. goto abort_unlock;
  2348. }
  2349. goto done_unlock;
  2350. }
  2351. if (!list_empty(&mddev->disks)) {
  2352. printk(KERN_WARNING
  2353. "md: array %s already has disks!\n",
  2354. mdname(mddev));
  2355. err = -EBUSY;
  2356. goto abort_unlock;
  2357. }
  2358. if (mddev->raid_disks) {
  2359. printk(KERN_WARNING
  2360. "md: array %s already initialised!\n",
  2361. mdname(mddev));
  2362. err = -EBUSY;
  2363. goto abort_unlock;
  2364. }
  2365. err = set_array_info(mddev, &info);
  2366. if (err) {
  2367. printk(KERN_WARNING "md: couldn't set"
  2368. " array info. %d\n", err);
  2369. goto abort_unlock;
  2370. }
  2371. }
  2372. goto done_unlock;
  2373. default:;
  2374. }
  2375. /*
  2376. * Commands querying/configuring an existing array:
  2377. */
  2378. /* if we are not initialised yet, only ADD_NEW_DISK, STOP_ARRAY,
  2379. * RUN_ARRAY, and SET_BITMAP_FILE are allowed */
  2380. if (!mddev->raid_disks && cmd != ADD_NEW_DISK && cmd != STOP_ARRAY
  2381. && cmd != RUN_ARRAY && cmd != SET_BITMAP_FILE) {
  2382. err = -ENODEV;
  2383. goto abort_unlock;
  2384. }
  2385. /*
  2386. * Commands even a read-only array can execute:
  2387. */
  2388. switch (cmd)
  2389. {
  2390. case GET_ARRAY_INFO:
  2391. err = get_array_info(mddev, argp);
  2392. goto done_unlock;
  2393. case GET_BITMAP_FILE:
  2394. err = get_bitmap_file(mddev, (void *)arg);
  2395. goto done_unlock;
  2396. case GET_DISK_INFO:
  2397. err = get_disk_info(mddev, argp);
  2398. goto done_unlock;
  2399. case RESTART_ARRAY_RW:
  2400. err = restart_array(mddev);
  2401. goto done_unlock;
  2402. case STOP_ARRAY:
  2403. err = do_md_stop (mddev, 0);
  2404. goto done_unlock;
  2405. case STOP_ARRAY_RO:
  2406. err = do_md_stop (mddev, 1);
  2407. goto done_unlock;
  2408. /*
  2409. * We have a problem here : there is no easy way to give a CHS
  2410. * virtual geometry. We currently pretend that we have a 2 heads
  2411. * 4 sectors (with a BIG number of cylinders...). This drives
  2412. * dosfs just mad... ;-)
  2413. */
  2414. case HDIO_GETGEO:
  2415. if (!loc) {
  2416. err = -EINVAL;
  2417. goto abort_unlock;
  2418. }
  2419. err = put_user (2, (char __user *) &loc->heads);
  2420. if (err)
  2421. goto abort_unlock;
  2422. err = put_user (4, (char __user *) &loc->sectors);
  2423. if (err)
  2424. goto abort_unlock;
  2425. err = put_user(get_capacity(mddev->gendisk)/8,
  2426. (short __user *) &loc->cylinders);
  2427. if (err)
  2428. goto abort_unlock;
  2429. err = put_user (get_start_sect(inode->i_bdev),
  2430. (long __user *) &loc->start);
  2431. goto done_unlock;
  2432. }
  2433. /*
  2434. * The remaining ioctls are changing the state of the
  2435. * superblock, so we do not allow read-only arrays
  2436. * here:
  2437. */
  2438. if (mddev->ro) {
  2439. err = -EROFS;
  2440. goto abort_unlock;
  2441. }
  2442. switch (cmd)
  2443. {
  2444. case ADD_NEW_DISK:
  2445. {
  2446. mdu_disk_info_t info;
  2447. if (copy_from_user(&info, argp, sizeof(info)))
  2448. err = -EFAULT;
  2449. else
  2450. err = add_new_disk(mddev, &info);
  2451. goto done_unlock;
  2452. }
  2453. case HOT_REMOVE_DISK:
  2454. err = hot_remove_disk(mddev, new_decode_dev(arg));
  2455. goto done_unlock;
  2456. case HOT_ADD_DISK:
  2457. err = hot_add_disk(mddev, new_decode_dev(arg));
  2458. goto done_unlock;
  2459. case SET_DISK_FAULTY:
  2460. err = set_disk_faulty(mddev, new_decode_dev(arg));
  2461. goto done_unlock;
  2462. case RUN_ARRAY:
  2463. err = do_md_run (mddev);
  2464. goto done_unlock;
  2465. case SET_BITMAP_FILE:
  2466. err = set_bitmap_file(mddev, (int)arg);
  2467. goto done_unlock;
  2468. default:
  2469. if (_IOC_TYPE(cmd) == MD_MAJOR)
  2470. printk(KERN_WARNING "md: %s(pid %d) used"
  2471. " obsolete MD ioctl, upgrade your"
  2472. " software to use new ictls.\n",
  2473. current->comm, current->pid);
  2474. err = -EINVAL;
  2475. goto abort_unlock;
  2476. }
  2477. done_unlock:
  2478. abort_unlock:
  2479. mddev_unlock(mddev);
  2480. return err;
  2481. done:
  2482. if (err)
  2483. MD_BUG();
  2484. abort:
  2485. return err;
  2486. }
  2487. static int md_open(struct inode *inode, struct file *file)
  2488. {
  2489. /*
  2490. * Succeed if we can lock the mddev, which confirms that
  2491. * it isn't being stopped right now.
  2492. */
  2493. mddev_t *mddev = inode->i_bdev->bd_disk->private_data;
  2494. int err;
  2495. if ((err = mddev_lock(mddev)))
  2496. goto out;
  2497. err = 0;
  2498. mddev_get(mddev);
  2499. mddev_unlock(mddev);
  2500. check_disk_change(inode->i_bdev);
  2501. out:
  2502. return err;
  2503. }
  2504. static int md_release(struct inode *inode, struct file * file)
  2505. {
  2506. mddev_t *mddev = inode->i_bdev->bd_disk->private_data;
  2507. if (!mddev)
  2508. BUG();
  2509. mddev_put(mddev);
  2510. return 0;
  2511. }
  2512. static int md_media_changed(struct gendisk *disk)
  2513. {
  2514. mddev_t *mddev = disk->private_data;
  2515. return mddev->changed;
  2516. }
  2517. static int md_revalidate(struct gendisk *disk)
  2518. {
  2519. mddev_t *mddev = disk->private_data;
  2520. mddev->changed = 0;
  2521. return 0;
  2522. }
  2523. static struct block_device_operations md_fops =
  2524. {
  2525. .owner = THIS_MODULE,
  2526. .open = md_open,
  2527. .release = md_release,
  2528. .ioctl = md_ioctl,
  2529. .media_changed = md_media_changed,
  2530. .revalidate_disk= md_revalidate,
  2531. };
  2532. static int md_thread(void * arg)
  2533. {
  2534. mdk_thread_t *thread = arg;
  2535. lock_kernel();
  2536. /*
  2537. * Detach thread
  2538. */
  2539. daemonize(thread->name, mdname(thread->mddev));
  2540. current->exit_signal = SIGCHLD;
  2541. allow_signal(SIGKILL);
  2542. thread->tsk = current;
  2543. /*
  2544. * md_thread is a 'system-thread', it's priority should be very
  2545. * high. We avoid resource deadlocks individually in each
  2546. * raid personality. (RAID5 does preallocation) We also use RR and
  2547. * the very same RT priority as kswapd, thus we will never get
  2548. * into a priority inversion deadlock.
  2549. *
  2550. * we definitely have to have equal or higher priority than
  2551. * bdflush, otherwise bdflush will deadlock if there are too
  2552. * many dirty RAID5 blocks.
  2553. */
  2554. unlock_kernel();
  2555. complete(thread->event);
  2556. while (thread->run) {
  2557. void (*run)(mddev_t *);
  2558. wait_event_interruptible_timeout(thread->wqueue,
  2559. test_bit(THREAD_WAKEUP, &thread->flags),
  2560. thread->timeout);
  2561. try_to_freeze();
  2562. clear_bit(THREAD_WAKEUP, &thread->flags);
  2563. run = thread->run;
  2564. if (run)
  2565. run(thread->mddev);
  2566. if (signal_pending(current))
  2567. flush_signals(current);
  2568. }
  2569. complete(thread->event);
  2570. return 0;
  2571. }
  2572. void md_wakeup_thread(mdk_thread_t *thread)
  2573. {
  2574. if (thread) {
  2575. dprintk("md: waking up MD thread %s.\n", thread->tsk->comm);
  2576. set_bit(THREAD_WAKEUP, &thread->flags);
  2577. wake_up(&thread->wqueue);
  2578. }
  2579. }
  2580. mdk_thread_t *md_register_thread(void (*run) (mddev_t *), mddev_t *mddev,
  2581. const char *name)
  2582. {
  2583. mdk_thread_t *thread;
  2584. int ret;
  2585. struct completion event;
  2586. thread = (mdk_thread_t *) kmalloc
  2587. (sizeof(mdk_thread_t), GFP_KERNEL);
  2588. if (!thread)
  2589. return NULL;
  2590. memset(thread, 0, sizeof(mdk_thread_t));
  2591. init_waitqueue_head(&thread->wqueue);
  2592. init_completion(&event);
  2593. thread->event = &event;
  2594. thread->run = run;
  2595. thread->mddev = mddev;
  2596. thread->name = name;
  2597. thread->timeout = MAX_SCHEDULE_TIMEOUT;
  2598. ret = kernel_thread(md_thread, thread, 0);
  2599. if (ret < 0) {
  2600. kfree(thread);
  2601. return NULL;
  2602. }
  2603. wait_for_completion(&event);
  2604. return thread;
  2605. }
  2606. void md_unregister_thread(mdk_thread_t *thread)
  2607. {
  2608. struct completion event;
  2609. init_completion(&event);
  2610. thread->event = &event;
  2611. /* As soon as ->run is set to NULL, the task could disappear,
  2612. * so we need to hold tasklist_lock until we have sent the signal
  2613. */
  2614. dprintk("interrupting MD-thread pid %d\n", thread->tsk->pid);
  2615. read_lock(&tasklist_lock);
  2616. thread->run = NULL;
  2617. send_sig(SIGKILL, thread->tsk, 1);
  2618. read_unlock(&tasklist_lock);
  2619. wait_for_completion(&event);
  2620. kfree(thread);
  2621. }
  2622. void md_error(mddev_t *mddev, mdk_rdev_t *rdev)
  2623. {
  2624. if (!mddev) {
  2625. MD_BUG();
  2626. return;
  2627. }
  2628. if (!rdev || rdev->faulty)
  2629. return;
  2630. /*
  2631. dprintk("md_error dev:%s, rdev:(%d:%d), (caller: %p,%p,%p,%p).\n",
  2632. mdname(mddev),
  2633. MAJOR(rdev->bdev->bd_dev), MINOR(rdev->bdev->bd_dev),
  2634. __builtin_return_address(0),__builtin_return_address(1),
  2635. __builtin_return_address(2),__builtin_return_address(3));
  2636. */
  2637. if (!mddev->pers->error_handler)
  2638. return;
  2639. mddev->pers->error_handler(mddev,rdev);
  2640. set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  2641. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  2642. md_wakeup_thread(mddev->thread);
  2643. }
  2644. /* seq_file implementation /proc/mdstat */
  2645. static void status_unused(struct seq_file *seq)
  2646. {
  2647. int i = 0;
  2648. mdk_rdev_t *rdev;
  2649. struct list_head *tmp;
  2650. seq_printf(seq, "unused devices: ");
  2651. ITERATE_RDEV_PENDING(rdev,tmp) {
  2652. char b[BDEVNAME_SIZE];
  2653. i++;
  2654. seq_printf(seq, "%s ",
  2655. bdevname(rdev->bdev,b));
  2656. }
  2657. if (!i)
  2658. seq_printf(seq, "<none>");
  2659. seq_printf(seq, "\n");
  2660. }
  2661. static void status_resync(struct seq_file *seq, mddev_t * mddev)
  2662. {
  2663. unsigned long max_blocks, resync, res, dt, db, rt;
  2664. resync = (mddev->curr_resync - atomic_read(&mddev->recovery_active))/2;
  2665. if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
  2666. max_blocks = mddev->resync_max_sectors >> 1;
  2667. else
  2668. max_blocks = mddev->size;
  2669. /*
  2670. * Should not happen.
  2671. */
  2672. if (!max_blocks) {
  2673. MD_BUG();
  2674. return;
  2675. }
  2676. res = (resync/1024)*1000/(max_blocks/1024 + 1);
  2677. {
  2678. int i, x = res/50, y = 20-x;
  2679. seq_printf(seq, "[");
  2680. for (i = 0; i < x; i++)
  2681. seq_printf(seq, "=");
  2682. seq_printf(seq, ">");
  2683. for (i = 0; i < y; i++)
  2684. seq_printf(seq, ".");
  2685. seq_printf(seq, "] ");
  2686. }
  2687. seq_printf(seq, " %s =%3lu.%lu%% (%lu/%lu)",
  2688. (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) ?
  2689. "resync" : "recovery"),
  2690. res/10, res % 10, resync, max_blocks);
  2691. /*
  2692. * We do not want to overflow, so the order of operands and
  2693. * the * 100 / 100 trick are important. We do a +1 to be
  2694. * safe against division by zero. We only estimate anyway.
  2695. *
  2696. * dt: time from mark until now
  2697. * db: blocks written from mark until now
  2698. * rt: remaining time
  2699. */
  2700. dt = ((jiffies - mddev->resync_mark) / HZ);
  2701. if (!dt) dt++;
  2702. db = resync - (mddev->resync_mark_cnt/2);
  2703. rt = (dt * ((max_blocks-resync) / (db/100+1)))/100;
  2704. seq_printf(seq, " finish=%lu.%lumin", rt / 60, (rt % 60)/6);
  2705. seq_printf(seq, " speed=%ldK/sec", db/dt);
  2706. }
  2707. static void *md_seq_start(struct seq_file *seq, loff_t *pos)
  2708. {
  2709. struct list_head *tmp;
  2710. loff_t l = *pos;
  2711. mddev_t *mddev;
  2712. if (l >= 0x10000)
  2713. return NULL;
  2714. if (!l--)
  2715. /* header */
  2716. return (void*)1;
  2717. spin_lock(&all_mddevs_lock);
  2718. list_for_each(tmp,&all_mddevs)
  2719. if (!l--) {
  2720. mddev = list_entry(tmp, mddev_t, all_mddevs);
  2721. mddev_get(mddev);
  2722. spin_unlock(&all_mddevs_lock);
  2723. return mddev;
  2724. }
  2725. spin_unlock(&all_mddevs_lock);
  2726. if (!l--)
  2727. return (void*)2;/* tail */
  2728. return NULL;
  2729. }
  2730. static void *md_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  2731. {
  2732. struct list_head *tmp;
  2733. mddev_t *next_mddev, *mddev = v;
  2734. ++*pos;
  2735. if (v == (void*)2)
  2736. return NULL;
  2737. spin_lock(&all_mddevs_lock);
  2738. if (v == (void*)1)
  2739. tmp = all_mddevs.next;
  2740. else
  2741. tmp = mddev->all_mddevs.next;
  2742. if (tmp != &all_mddevs)
  2743. next_mddev = mddev_get(list_entry(tmp,mddev_t,all_mddevs));
  2744. else {
  2745. next_mddev = (void*)2;
  2746. *pos = 0x10000;
  2747. }
  2748. spin_unlock(&all_mddevs_lock);
  2749. if (v != (void*)1)
  2750. mddev_put(mddev);
  2751. return next_mddev;
  2752. }
  2753. static void md_seq_stop(struct seq_file *seq, void *v)
  2754. {
  2755. mddev_t *mddev = v;
  2756. if (mddev && v != (void*)1 && v != (void*)2)
  2757. mddev_put(mddev);
  2758. }
  2759. static int md_seq_show(struct seq_file *seq, void *v)
  2760. {
  2761. mddev_t *mddev = v;
  2762. sector_t size;
  2763. struct list_head *tmp2;
  2764. mdk_rdev_t *rdev;
  2765. int i;
  2766. struct bitmap *bitmap;
  2767. if (v == (void*)1) {
  2768. seq_printf(seq, "Personalities : ");
  2769. spin_lock(&pers_lock);
  2770. for (i = 0; i < MAX_PERSONALITY; i++)
  2771. if (pers[i])
  2772. seq_printf(seq, "[%s] ", pers[i]->name);
  2773. spin_unlock(&pers_lock);
  2774. seq_printf(seq, "\n");
  2775. return 0;
  2776. }
  2777. if (v == (void*)2) {
  2778. status_unused(seq);
  2779. return 0;
  2780. }
  2781. if (mddev_lock(mddev)!=0)
  2782. return -EINTR;
  2783. if (mddev->pers || mddev->raid_disks || !list_empty(&mddev->disks)) {
  2784. seq_printf(seq, "%s : %sactive", mdname(mddev),
  2785. mddev->pers ? "" : "in");
  2786. if (mddev->pers) {
  2787. if (mddev->ro)
  2788. seq_printf(seq, " (read-only)");
  2789. seq_printf(seq, " %s", mddev->pers->name);
  2790. }
  2791. size = 0;
  2792. ITERATE_RDEV(mddev,rdev,tmp2) {
  2793. char b[BDEVNAME_SIZE];
  2794. seq_printf(seq, " %s[%d]",
  2795. bdevname(rdev->bdev,b), rdev->desc_nr);
  2796. if (rdev->faulty) {
  2797. seq_printf(seq, "(F)");
  2798. continue;
  2799. }
  2800. size += rdev->size;
  2801. }
  2802. if (!list_empty(&mddev->disks)) {
  2803. if (mddev->pers)
  2804. seq_printf(seq, "\n %llu blocks",
  2805. (unsigned long long)mddev->array_size);
  2806. else
  2807. seq_printf(seq, "\n %llu blocks",
  2808. (unsigned long long)size);
  2809. }
  2810. if (mddev->pers) {
  2811. mddev->pers->status (seq, mddev);
  2812. seq_printf(seq, "\n ");
  2813. if (mddev->curr_resync > 2) {
  2814. status_resync (seq, mddev);
  2815. seq_printf(seq, "\n ");
  2816. } else if (mddev->curr_resync == 1 || mddev->curr_resync == 2)
  2817. seq_printf(seq, " resync=DELAYED\n ");
  2818. } else
  2819. seq_printf(seq, "\n ");
  2820. if ((bitmap = mddev->bitmap)) {
  2821. unsigned long chunk_kb;
  2822. unsigned long flags;
  2823. spin_lock_irqsave(&bitmap->lock, flags);
  2824. chunk_kb = bitmap->chunksize >> 10;
  2825. seq_printf(seq, "bitmap: %lu/%lu pages [%luKB], "
  2826. "%lu%s chunk",
  2827. bitmap->pages - bitmap->missing_pages,
  2828. bitmap->pages,
  2829. (bitmap->pages - bitmap->missing_pages)
  2830. << (PAGE_SHIFT - 10),
  2831. chunk_kb ? chunk_kb : bitmap->chunksize,
  2832. chunk_kb ? "KB" : "B");
  2833. if (bitmap->file) {
  2834. seq_printf(seq, ", file: ");
  2835. seq_path(seq, bitmap->file->f_vfsmnt,
  2836. bitmap->file->f_dentry," \t\n");
  2837. }
  2838. seq_printf(seq, "\n");
  2839. spin_unlock_irqrestore(&bitmap->lock, flags);
  2840. }
  2841. seq_printf(seq, "\n");
  2842. }
  2843. mddev_unlock(mddev);
  2844. return 0;
  2845. }
  2846. static struct seq_operations md_seq_ops = {
  2847. .start = md_seq_start,
  2848. .next = md_seq_next,
  2849. .stop = md_seq_stop,
  2850. .show = md_seq_show,
  2851. };
  2852. static int md_seq_open(struct inode *inode, struct file *file)
  2853. {
  2854. int error;
  2855. error = seq_open(file, &md_seq_ops);
  2856. return error;
  2857. }
  2858. static struct file_operations md_seq_fops = {
  2859. .open = md_seq_open,
  2860. .read = seq_read,
  2861. .llseek = seq_lseek,
  2862. .release = seq_release,
  2863. };
  2864. int register_md_personality(int pnum, mdk_personality_t *p)
  2865. {
  2866. if (pnum >= MAX_PERSONALITY) {
  2867. printk(KERN_ERR
  2868. "md: tried to install personality %s as nr %d, but max is %lu\n",
  2869. p->name, pnum, MAX_PERSONALITY-1);
  2870. return -EINVAL;
  2871. }
  2872. spin_lock(&pers_lock);
  2873. if (pers[pnum]) {
  2874. spin_unlock(&pers_lock);
  2875. return -EBUSY;
  2876. }
  2877. pers[pnum] = p;
  2878. printk(KERN_INFO "md: %s personality registered as nr %d\n", p->name, pnum);
  2879. spin_unlock(&pers_lock);
  2880. return 0;
  2881. }
  2882. int unregister_md_personality(int pnum)
  2883. {
  2884. if (pnum >= MAX_PERSONALITY)
  2885. return -EINVAL;
  2886. printk(KERN_INFO "md: %s personality unregistered\n", pers[pnum]->name);
  2887. spin_lock(&pers_lock);
  2888. pers[pnum] = NULL;
  2889. spin_unlock(&pers_lock);
  2890. return 0;
  2891. }
  2892. static int is_mddev_idle(mddev_t *mddev)
  2893. {
  2894. mdk_rdev_t * rdev;
  2895. struct list_head *tmp;
  2896. int idle;
  2897. unsigned long curr_events;
  2898. idle = 1;
  2899. ITERATE_RDEV(mddev,rdev,tmp) {
  2900. struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
  2901. curr_events = disk_stat_read(disk, read_sectors) +
  2902. disk_stat_read(disk, write_sectors) -
  2903. atomic_read(&disk->sync_io);
  2904. /* Allow some slack between valud of curr_events and last_events,
  2905. * as there are some uninteresting races.
  2906. * Note: the following is an unsigned comparison.
  2907. */
  2908. if ((curr_events - rdev->last_events + 32) > 64) {
  2909. rdev->last_events = curr_events;
  2910. idle = 0;
  2911. }
  2912. }
  2913. return idle;
  2914. }
  2915. void md_done_sync(mddev_t *mddev, int blocks, int ok)
  2916. {
  2917. /* another "blocks" (512byte) blocks have been synced */
  2918. atomic_sub(blocks, &mddev->recovery_active);
  2919. wake_up(&mddev->recovery_wait);
  2920. if (!ok) {
  2921. set_bit(MD_RECOVERY_ERR, &mddev->recovery);
  2922. md_wakeup_thread(mddev->thread);
  2923. // stop recovery, signal do_sync ....
  2924. }
  2925. }
  2926. /* md_write_start(mddev, bi)
  2927. * If we need to update some array metadata (e.g. 'active' flag
  2928. * in superblock) before writing, schedule a superblock update
  2929. * and wait for it to complete.
  2930. */
  2931. void md_write_start(mddev_t *mddev, struct bio *bi)
  2932. {
  2933. DEFINE_WAIT(w);
  2934. if (bio_data_dir(bi) != WRITE)
  2935. return;
  2936. atomic_inc(&mddev->writes_pending);
  2937. if (mddev->in_sync) {
  2938. spin_lock(&mddev->write_lock);
  2939. if (mddev->in_sync) {
  2940. mddev->in_sync = 0;
  2941. mddev->sb_dirty = 1;
  2942. md_wakeup_thread(mddev->thread);
  2943. }
  2944. spin_unlock(&mddev->write_lock);
  2945. }
  2946. wait_event(mddev->sb_wait, mddev->sb_dirty==0);
  2947. }
  2948. void md_write_end(mddev_t *mddev)
  2949. {
  2950. if (atomic_dec_and_test(&mddev->writes_pending)) {
  2951. if (mddev->safemode == 2)
  2952. md_wakeup_thread(mddev->thread);
  2953. else
  2954. mod_timer(&mddev->safemode_timer, jiffies + mddev->safemode_delay);
  2955. }
  2956. }
  2957. static DECLARE_WAIT_QUEUE_HEAD(resync_wait);
  2958. #define SYNC_MARKS 10
  2959. #define SYNC_MARK_STEP (3*HZ)
  2960. static void md_do_sync(mddev_t *mddev)
  2961. {
  2962. mddev_t *mddev2;
  2963. unsigned int currspeed = 0,
  2964. window;
  2965. sector_t max_sectors,j, io_sectors;
  2966. unsigned long mark[SYNC_MARKS];
  2967. sector_t mark_cnt[SYNC_MARKS];
  2968. int last_mark,m;
  2969. struct list_head *tmp;
  2970. sector_t last_check;
  2971. int skipped = 0;
  2972. /* just incase thread restarts... */
  2973. if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
  2974. return;
  2975. /* we overload curr_resync somewhat here.
  2976. * 0 == not engaged in resync at all
  2977. * 2 == checking that there is no conflict with another sync
  2978. * 1 == like 2, but have yielded to allow conflicting resync to
  2979. * commense
  2980. * other == active in resync - this many blocks
  2981. *
  2982. * Before starting a resync we must have set curr_resync to
  2983. * 2, and then checked that every "conflicting" array has curr_resync
  2984. * less than ours. When we find one that is the same or higher
  2985. * we wait on resync_wait. To avoid deadlock, we reduce curr_resync
  2986. * to 1 if we choose to yield (based arbitrarily on address of mddev structure).
  2987. * This will mean we have to start checking from the beginning again.
  2988. *
  2989. */
  2990. do {
  2991. mddev->curr_resync = 2;
  2992. try_again:
  2993. if (signal_pending(current)) {
  2994. flush_signals(current);
  2995. goto skip;
  2996. }
  2997. ITERATE_MDDEV(mddev2,tmp) {
  2998. if (mddev2 == mddev)
  2999. continue;
  3000. if (mddev2->curr_resync &&
  3001. match_mddev_units(mddev,mddev2)) {
  3002. DEFINE_WAIT(wq);
  3003. if (mddev < mddev2 && mddev->curr_resync == 2) {
  3004. /* arbitrarily yield */
  3005. mddev->curr_resync = 1;
  3006. wake_up(&resync_wait);
  3007. }
  3008. if (mddev > mddev2 && mddev->curr_resync == 1)
  3009. /* no need to wait here, we can wait the next
  3010. * time 'round when curr_resync == 2
  3011. */
  3012. continue;
  3013. prepare_to_wait(&resync_wait, &wq, TASK_INTERRUPTIBLE);
  3014. if (!signal_pending(current)
  3015. && mddev2->curr_resync >= mddev->curr_resync) {
  3016. printk(KERN_INFO "md: delaying resync of %s"
  3017. " until %s has finished resync (they"
  3018. " share one or more physical units)\n",
  3019. mdname(mddev), mdname(mddev2));
  3020. mddev_put(mddev2);
  3021. schedule();
  3022. finish_wait(&resync_wait, &wq);
  3023. goto try_again;
  3024. }
  3025. finish_wait(&resync_wait, &wq);
  3026. }
  3027. }
  3028. } while (mddev->curr_resync < 2);
  3029. if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery))
  3030. /* resync follows the size requested by the personality,
  3031. * which defaults to physical size, but can be virtual size
  3032. */
  3033. max_sectors = mddev->resync_max_sectors;
  3034. else
  3035. /* recovery follows the physical size of devices */
  3036. max_sectors = mddev->size << 1;
  3037. printk(KERN_INFO "md: syncing RAID array %s\n", mdname(mddev));
  3038. printk(KERN_INFO "md: minimum _guaranteed_ reconstruction speed:"
  3039. " %d KB/sec/disc.\n", sysctl_speed_limit_min);
  3040. printk(KERN_INFO "md: using maximum available idle IO bandwith "
  3041. "(but not more than %d KB/sec) for reconstruction.\n",
  3042. sysctl_speed_limit_max);
  3043. is_mddev_idle(mddev); /* this also initializes IO event counters */
  3044. /* we don't use the checkpoint if there's a bitmap */
  3045. if (test_bit(MD_RECOVERY_SYNC, &mddev->recovery) && !mddev->bitmap)
  3046. j = mddev->recovery_cp;
  3047. else
  3048. j = 0;
  3049. io_sectors = 0;
  3050. for (m = 0; m < SYNC_MARKS; m++) {
  3051. mark[m] = jiffies;
  3052. mark_cnt[m] = io_sectors;
  3053. }
  3054. last_mark = 0;
  3055. mddev->resync_mark = mark[last_mark];
  3056. mddev->resync_mark_cnt = mark_cnt[last_mark];
  3057. /*
  3058. * Tune reconstruction:
  3059. */
  3060. window = 32*(PAGE_SIZE/512);
  3061. printk(KERN_INFO "md: using %dk window, over a total of %llu blocks.\n",
  3062. window/2,(unsigned long long) max_sectors/2);
  3063. atomic_set(&mddev->recovery_active, 0);
  3064. init_waitqueue_head(&mddev->recovery_wait);
  3065. last_check = 0;
  3066. if (j>2) {
  3067. printk(KERN_INFO
  3068. "md: resuming recovery of %s from checkpoint.\n",
  3069. mdname(mddev));
  3070. mddev->curr_resync = j;
  3071. }
  3072. while (j < max_sectors) {
  3073. sector_t sectors;
  3074. skipped = 0;
  3075. sectors = mddev->pers->sync_request(mddev, j, &skipped,
  3076. currspeed < sysctl_speed_limit_min);
  3077. if (sectors == 0) {
  3078. set_bit(MD_RECOVERY_ERR, &mddev->recovery);
  3079. goto out;
  3080. }
  3081. if (!skipped) { /* actual IO requested */
  3082. io_sectors += sectors;
  3083. atomic_add(sectors, &mddev->recovery_active);
  3084. }
  3085. j += sectors;
  3086. if (j>1) mddev->curr_resync = j;
  3087. if (last_check + window > io_sectors || j == max_sectors)
  3088. continue;
  3089. last_check = io_sectors;
  3090. if (test_bit(MD_RECOVERY_INTR, &mddev->recovery) ||
  3091. test_bit(MD_RECOVERY_ERR, &mddev->recovery))
  3092. break;
  3093. repeat:
  3094. if (time_after_eq(jiffies, mark[last_mark] + SYNC_MARK_STEP )) {
  3095. /* step marks */
  3096. int next = (last_mark+1) % SYNC_MARKS;
  3097. mddev->resync_mark = mark[next];
  3098. mddev->resync_mark_cnt = mark_cnt[next];
  3099. mark[next] = jiffies;
  3100. mark_cnt[next] = io_sectors - atomic_read(&mddev->recovery_active);
  3101. last_mark = next;
  3102. }
  3103. if (signal_pending(current)) {
  3104. /*
  3105. * got a signal, exit.
  3106. */
  3107. printk(KERN_INFO
  3108. "md: md_do_sync() got signal ... exiting\n");
  3109. flush_signals(current);
  3110. set_bit(MD_RECOVERY_INTR, &mddev->recovery);
  3111. goto out;
  3112. }
  3113. /*
  3114. * this loop exits only if either when we are slower than
  3115. * the 'hard' speed limit, or the system was IO-idle for
  3116. * a jiffy.
  3117. * the system might be non-idle CPU-wise, but we only care
  3118. * about not overloading the IO subsystem. (things like an
  3119. * e2fsck being done on the RAID array should execute fast)
  3120. */
  3121. mddev->queue->unplug_fn(mddev->queue);
  3122. cond_resched();
  3123. currspeed = ((unsigned long)(io_sectors-mddev->resync_mark_cnt))/2
  3124. /((jiffies-mddev->resync_mark)/HZ +1) +1;
  3125. if (currspeed > sysctl_speed_limit_min) {
  3126. if ((currspeed > sysctl_speed_limit_max) ||
  3127. !is_mddev_idle(mddev)) {
  3128. msleep_interruptible(250);
  3129. goto repeat;
  3130. }
  3131. }
  3132. }
  3133. printk(KERN_INFO "md: %s: sync done.\n",mdname(mddev));
  3134. /*
  3135. * this also signals 'finished resyncing' to md_stop
  3136. */
  3137. out:
  3138. mddev->queue->unplug_fn(mddev->queue);
  3139. wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
  3140. /* tell personality that we are finished */
  3141. mddev->pers->sync_request(mddev, max_sectors, &skipped, 1);
  3142. if (!test_bit(MD_RECOVERY_ERR, &mddev->recovery) &&
  3143. mddev->curr_resync > 2 &&
  3144. mddev->curr_resync >= mddev->recovery_cp) {
  3145. if (test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
  3146. printk(KERN_INFO
  3147. "md: checkpointing recovery of %s.\n",
  3148. mdname(mddev));
  3149. mddev->recovery_cp = mddev->curr_resync;
  3150. } else
  3151. mddev->recovery_cp = MaxSector;
  3152. }
  3153. skip:
  3154. mddev->curr_resync = 0;
  3155. wake_up(&resync_wait);
  3156. set_bit(MD_RECOVERY_DONE, &mddev->recovery);
  3157. md_wakeup_thread(mddev->thread);
  3158. }
  3159. /*
  3160. * This routine is regularly called by all per-raid-array threads to
  3161. * deal with generic issues like resync and super-block update.
  3162. * Raid personalities that don't have a thread (linear/raid0) do not
  3163. * need this as they never do any recovery or update the superblock.
  3164. *
  3165. * It does not do any resync itself, but rather "forks" off other threads
  3166. * to do that as needed.
  3167. * When it is determined that resync is needed, we set MD_RECOVERY_RUNNING in
  3168. * "->recovery" and create a thread at ->sync_thread.
  3169. * When the thread finishes it sets MD_RECOVERY_DONE (and might set MD_RECOVERY_ERR)
  3170. * and wakeups up this thread which will reap the thread and finish up.
  3171. * This thread also removes any faulty devices (with nr_pending == 0).
  3172. *
  3173. * The overall approach is:
  3174. * 1/ if the superblock needs updating, update it.
  3175. * 2/ If a recovery thread is running, don't do anything else.
  3176. * 3/ If recovery has finished, clean up, possibly marking spares active.
  3177. * 4/ If there are any faulty devices, remove them.
  3178. * 5/ If array is degraded, try to add spares devices
  3179. * 6/ If array has spares or is not in-sync, start a resync thread.
  3180. */
  3181. void md_check_recovery(mddev_t *mddev)
  3182. {
  3183. mdk_rdev_t *rdev;
  3184. struct list_head *rtmp;
  3185. if (mddev->bitmap)
  3186. bitmap_daemon_work(mddev->bitmap);
  3187. if (mddev->ro)
  3188. return;
  3189. if (signal_pending(current)) {
  3190. if (mddev->pers->sync_request) {
  3191. printk(KERN_INFO "md: %s in immediate safe mode\n",
  3192. mdname(mddev));
  3193. mddev->safemode = 2;
  3194. }
  3195. flush_signals(current);
  3196. }
  3197. if ( ! (
  3198. mddev->sb_dirty ||
  3199. test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) ||
  3200. test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
  3201. (mddev->safemode == 1) ||
  3202. (mddev->safemode == 2 && ! atomic_read(&mddev->writes_pending)
  3203. && !mddev->in_sync && mddev->recovery_cp == MaxSector)
  3204. ))
  3205. return;
  3206. if (mddev_trylock(mddev)==0) {
  3207. int spares =0;
  3208. spin_lock(&mddev->write_lock);
  3209. if (mddev->safemode && !atomic_read(&mddev->writes_pending) &&
  3210. !mddev->in_sync && mddev->recovery_cp == MaxSector) {
  3211. mddev->in_sync = 1;
  3212. mddev->sb_dirty = 1;
  3213. }
  3214. if (mddev->safemode == 1)
  3215. mddev->safemode = 0;
  3216. spin_unlock(&mddev->write_lock);
  3217. if (mddev->sb_dirty)
  3218. md_update_sb(mddev);
  3219. if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery) &&
  3220. !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
  3221. /* resync/recovery still happening */
  3222. clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  3223. goto unlock;
  3224. }
  3225. if (mddev->sync_thread) {
  3226. /* resync has finished, collect result */
  3227. md_unregister_thread(mddev->sync_thread);
  3228. mddev->sync_thread = NULL;
  3229. if (!test_bit(MD_RECOVERY_ERR, &mddev->recovery) &&
  3230. !test_bit(MD_RECOVERY_INTR, &mddev->recovery)) {
  3231. /* success...*/
  3232. /* activate any spares */
  3233. mddev->pers->spare_active(mddev);
  3234. }
  3235. md_update_sb(mddev);
  3236. /* if array is no-longer degraded, then any saved_raid_disk
  3237. * information must be scrapped
  3238. */
  3239. if (!mddev->degraded)
  3240. ITERATE_RDEV(mddev,rdev,rtmp)
  3241. rdev->saved_raid_disk = -1;
  3242. mddev->recovery = 0;
  3243. /* flag recovery needed just to double check */
  3244. set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
  3245. goto unlock;
  3246. }
  3247. if (mddev->recovery)
  3248. /* probably just the RECOVERY_NEEDED flag */
  3249. mddev->recovery = 0;
  3250. /* no recovery is running.
  3251. * remove any failed drives, then
  3252. * add spares if possible.
  3253. * Spare are also removed and re-added, to allow
  3254. * the personality to fail the re-add.
  3255. */
  3256. ITERATE_RDEV(mddev,rdev,rtmp)
  3257. if (rdev->raid_disk >= 0 &&
  3258. (rdev->faulty || ! rdev->in_sync) &&
  3259. atomic_read(&rdev->nr_pending)==0) {
  3260. if (mddev->pers->hot_remove_disk(mddev, rdev->raid_disk)==0)
  3261. rdev->raid_disk = -1;
  3262. }
  3263. if (mddev->degraded) {
  3264. ITERATE_RDEV(mddev,rdev,rtmp)
  3265. if (rdev->raid_disk < 0
  3266. && !rdev->faulty) {
  3267. if (mddev->pers->hot_add_disk(mddev,rdev))
  3268. spares++;
  3269. else
  3270. break;
  3271. }
  3272. }
  3273. if (!spares && (mddev->recovery_cp == MaxSector )) {
  3274. /* nothing we can do ... */
  3275. goto unlock;
  3276. }
  3277. if (mddev->pers->sync_request) {
  3278. set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
  3279. if (!spares)
  3280. set_bit(MD_RECOVERY_SYNC, &mddev->recovery);
  3281. if (spares && mddev->bitmap && ! mddev->bitmap->file) {
  3282. /* We are adding a device or devices to an array
  3283. * which has the bitmap stored on all devices.
  3284. * So make sure all bitmap pages get written
  3285. */
  3286. bitmap_write_all(mddev->bitmap);
  3287. }
  3288. mddev->sync_thread = md_register_thread(md_do_sync,
  3289. mddev,
  3290. "%s_resync");
  3291. if (!mddev->sync_thread) {
  3292. printk(KERN_ERR "%s: could not start resync"
  3293. " thread...\n",
  3294. mdname(mddev));
  3295. /* leave the spares where they are, it shouldn't hurt */
  3296. mddev->recovery = 0;
  3297. } else {
  3298. md_wakeup_thread(mddev->sync_thread);
  3299. }
  3300. }
  3301. unlock:
  3302. mddev_unlock(mddev);
  3303. }
  3304. }
  3305. static int md_notify_reboot(struct notifier_block *this,
  3306. unsigned long code, void *x)
  3307. {
  3308. struct list_head *tmp;
  3309. mddev_t *mddev;
  3310. if ((code == SYS_DOWN) || (code == SYS_HALT) || (code == SYS_POWER_OFF)) {
  3311. printk(KERN_INFO "md: stopping all md devices.\n");
  3312. ITERATE_MDDEV(mddev,tmp)
  3313. if (mddev_trylock(mddev)==0)
  3314. do_md_stop (mddev, 1);
  3315. /*
  3316. * certain more exotic SCSI devices are known to be
  3317. * volatile wrt too early system reboots. While the
  3318. * right place to handle this issue is the given
  3319. * driver, we do want to have a safe RAID driver ...
  3320. */
  3321. mdelay(1000*1);
  3322. }
  3323. return NOTIFY_DONE;
  3324. }
  3325. static struct notifier_block md_notifier = {
  3326. .notifier_call = md_notify_reboot,
  3327. .next = NULL,
  3328. .priority = INT_MAX, /* before any real devices */
  3329. };
  3330. static void md_geninit(void)
  3331. {
  3332. struct proc_dir_entry *p;
  3333. dprintk("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
  3334. p = create_proc_entry("mdstat", S_IRUGO, NULL);
  3335. if (p)
  3336. p->proc_fops = &md_seq_fops;
  3337. }
  3338. static int __init md_init(void)
  3339. {
  3340. int minor;
  3341. printk(KERN_INFO "md: md driver %d.%d.%d MAX_MD_DEVS=%d,"
  3342. " MD_SB_DISKS=%d\n",
  3343. MD_MAJOR_VERSION, MD_MINOR_VERSION,
  3344. MD_PATCHLEVEL_VERSION, MAX_MD_DEVS, MD_SB_DISKS);
  3345. printk(KERN_INFO "md: bitmap version %d.%d\n", BITMAP_MAJOR,
  3346. BITMAP_MINOR);
  3347. if (register_blkdev(MAJOR_NR, "md"))
  3348. return -1;
  3349. if ((mdp_major=register_blkdev(0, "mdp"))<=0) {
  3350. unregister_blkdev(MAJOR_NR, "md");
  3351. return -1;
  3352. }
  3353. devfs_mk_dir("md");
  3354. blk_register_region(MKDEV(MAJOR_NR, 0), MAX_MD_DEVS, THIS_MODULE,
  3355. md_probe, NULL, NULL);
  3356. blk_register_region(MKDEV(mdp_major, 0), MAX_MD_DEVS<<MdpMinorShift, THIS_MODULE,
  3357. md_probe, NULL, NULL);
  3358. for (minor=0; minor < MAX_MD_DEVS; ++minor)
  3359. devfs_mk_bdev(MKDEV(MAJOR_NR, minor),
  3360. S_IFBLK|S_IRUSR|S_IWUSR,
  3361. "md/%d", minor);
  3362. for (minor=0; minor < MAX_MD_DEVS; ++minor)
  3363. devfs_mk_bdev(MKDEV(mdp_major, minor<<MdpMinorShift),
  3364. S_IFBLK|S_IRUSR|S_IWUSR,
  3365. "md/mdp%d", minor);
  3366. register_reboot_notifier(&md_notifier);
  3367. raid_table_header = register_sysctl_table(raid_root_table, 1);
  3368. md_geninit();
  3369. return (0);
  3370. }
  3371. #ifndef MODULE
  3372. /*
  3373. * Searches all registered partitions for autorun RAID arrays
  3374. * at boot time.
  3375. */
  3376. static dev_t detected_devices[128];
  3377. static int dev_cnt;
  3378. void md_autodetect_dev(dev_t dev)
  3379. {
  3380. if (dev_cnt >= 0 && dev_cnt < 127)
  3381. detected_devices[dev_cnt++] = dev;
  3382. }
  3383. static void autostart_arrays(int part)
  3384. {
  3385. mdk_rdev_t *rdev;
  3386. int i;
  3387. printk(KERN_INFO "md: Autodetecting RAID arrays.\n");
  3388. for (i = 0; i < dev_cnt; i++) {
  3389. dev_t dev = detected_devices[i];
  3390. rdev = md_import_device(dev,0, 0);
  3391. if (IS_ERR(rdev))
  3392. continue;
  3393. if (rdev->faulty) {
  3394. MD_BUG();
  3395. continue;
  3396. }
  3397. list_add(&rdev->same_set, &pending_raid_disks);
  3398. }
  3399. dev_cnt = 0;
  3400. autorun_devices(part);
  3401. }
  3402. #endif
  3403. static __exit void md_exit(void)
  3404. {
  3405. mddev_t *mddev;
  3406. struct list_head *tmp;
  3407. int i;
  3408. blk_unregister_region(MKDEV(MAJOR_NR,0), MAX_MD_DEVS);
  3409. blk_unregister_region(MKDEV(mdp_major,0), MAX_MD_DEVS << MdpMinorShift);
  3410. for (i=0; i < MAX_MD_DEVS; i++)
  3411. devfs_remove("md/%d", i);
  3412. for (i=0; i < MAX_MD_DEVS; i++)
  3413. devfs_remove("md/d%d", i);
  3414. devfs_remove("md");
  3415. unregister_blkdev(MAJOR_NR,"md");
  3416. unregister_blkdev(mdp_major, "mdp");
  3417. unregister_reboot_notifier(&md_notifier);
  3418. unregister_sysctl_table(raid_table_header);
  3419. remove_proc_entry("mdstat", NULL);
  3420. ITERATE_MDDEV(mddev,tmp) {
  3421. struct gendisk *disk = mddev->gendisk;
  3422. if (!disk)
  3423. continue;
  3424. export_array(mddev);
  3425. del_gendisk(disk);
  3426. put_disk(disk);
  3427. mddev->gendisk = NULL;
  3428. mddev_put(mddev);
  3429. }
  3430. }
  3431. module_init(md_init)
  3432. module_exit(md_exit)
  3433. EXPORT_SYMBOL(register_md_personality);
  3434. EXPORT_SYMBOL(unregister_md_personality);
  3435. EXPORT_SYMBOL(md_error);
  3436. EXPORT_SYMBOL(md_done_sync);
  3437. EXPORT_SYMBOL(md_write_start);
  3438. EXPORT_SYMBOL(md_write_end);
  3439. EXPORT_SYMBOL(md_register_thread);
  3440. EXPORT_SYMBOL(md_unregister_thread);
  3441. EXPORT_SYMBOL(md_wakeup_thread);
  3442. EXPORT_SYMBOL(md_print_devices);
  3443. EXPORT_SYMBOL(md_check_recovery);
  3444. MODULE_LICENSE("GPL");
  3445. MODULE_ALIAS("md");