md.c 111 KB

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