drbd_receiver.c 135 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508450945104511451245134514451545164517451845194520452145224523452445254526452745284529453045314532453345344535453645374538453945404541454245434544454545464547454845494550455145524553455445554556455745584559456045614562456345644565456645674568456945704571457245734574457545764577457845794580458145824583458445854586458745884589459045914592459345944595459645974598459946004601460246034604460546064607460846094610461146124613461446154616461746184619462046214622462346244625462646274628462946304631463246334634463546364637463846394640464146424643464446454646464746484649465046514652465346544655465646574658465946604661466246634664466546664667466846694670467146724673467446754676467746784679468046814682468346844685468646874688468946904691469246934694469546964697469846994700470147024703470447054706470747084709471047114712471347144715471647174718471947204721472247234724472547264727472847294730473147324733473447354736473747384739474047414742474347444745474647474748474947504751475247534754475547564757475847594760476147624763476447654766476747684769477047714772477347744775477647774778477947804781478247834784478547864787478847894790479147924793479447954796479747984799480048014802480348044805480648074808480948104811481248134814481548164817481848194820482148224823482448254826482748284829483048314832483348344835483648374838483948404841484248434844484548464847484848494850485148524853485448554856485748584859486048614862486348644865486648674868486948704871487248734874487548764877487848794880488148824883488448854886488748884889489048914892489348944895489648974898489949004901490249034904490549064907490849094910491149124913491449154916491749184919492049214922492349244925492649274928492949304931493249334934493549364937493849394940494149424943494449454946494749484949495049514952495349544955495649574958495949604961496249634964496549664967496849694970
  1. /*
  2. drbd_receiver.c
  3. This file is part of DRBD by Philipp Reisner and Lars Ellenberg.
  4. Copyright (C) 2001-2008, LINBIT Information Technologies GmbH.
  5. Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>.
  6. Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>.
  7. drbd is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2, or (at your option)
  10. any later version.
  11. drbd is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. GNU General Public License for more details.
  15. You should have received a copy of the GNU General Public License
  16. along with drbd; see the file COPYING. If not, write to
  17. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18. */
  19. #include <linux/module.h>
  20. #include <asm/uaccess.h>
  21. #include <net/sock.h>
  22. #include <linux/drbd.h>
  23. #include <linux/fs.h>
  24. #include <linux/file.h>
  25. #include <linux/in.h>
  26. #include <linux/mm.h>
  27. #include <linux/memcontrol.h>
  28. #include <linux/mm_inline.h>
  29. #include <linux/slab.h>
  30. #include <linux/pkt_sched.h>
  31. #define __KERNEL_SYSCALLS__
  32. #include <linux/unistd.h>
  33. #include <linux/vmalloc.h>
  34. #include <linux/random.h>
  35. #include <linux/string.h>
  36. #include <linux/scatterlist.h>
  37. #include "drbd_int.h"
  38. #include "drbd_req.h"
  39. #include "drbd_vli.h"
  40. struct packet_info {
  41. enum drbd_packet cmd;
  42. unsigned int size;
  43. unsigned int vnr;
  44. };
  45. enum finish_epoch {
  46. FE_STILL_LIVE,
  47. FE_DESTROYED,
  48. FE_RECYCLED,
  49. };
  50. static int drbd_do_handshake(struct drbd_tconn *tconn);
  51. static int drbd_do_auth(struct drbd_tconn *tconn);
  52. static int drbd_disconnected(int vnr, void *p, void *data);
  53. static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *, struct drbd_epoch *, enum epoch_event);
  54. static int e_end_block(struct drbd_work *, int);
  55. #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN)
  56. /*
  57. * some helper functions to deal with single linked page lists,
  58. * page->private being our "next" pointer.
  59. */
  60. /* If at least n pages are linked at head, get n pages off.
  61. * Otherwise, don't modify head, and return NULL.
  62. * Locking is the responsibility of the caller.
  63. */
  64. static struct page *page_chain_del(struct page **head, int n)
  65. {
  66. struct page *page;
  67. struct page *tmp;
  68. BUG_ON(!n);
  69. BUG_ON(!head);
  70. page = *head;
  71. if (!page)
  72. return NULL;
  73. while (page) {
  74. tmp = page_chain_next(page);
  75. if (--n == 0)
  76. break; /* found sufficient pages */
  77. if (tmp == NULL)
  78. /* insufficient pages, don't use any of them. */
  79. return NULL;
  80. page = tmp;
  81. }
  82. /* add end of list marker for the returned list */
  83. set_page_private(page, 0);
  84. /* actual return value, and adjustment of head */
  85. page = *head;
  86. *head = tmp;
  87. return page;
  88. }
  89. /* may be used outside of locks to find the tail of a (usually short)
  90. * "private" page chain, before adding it back to a global chain head
  91. * with page_chain_add() under a spinlock. */
  92. static struct page *page_chain_tail(struct page *page, int *len)
  93. {
  94. struct page *tmp;
  95. int i = 1;
  96. while ((tmp = page_chain_next(page)))
  97. ++i, page = tmp;
  98. if (len)
  99. *len = i;
  100. return page;
  101. }
  102. static int page_chain_free(struct page *page)
  103. {
  104. struct page *tmp;
  105. int i = 0;
  106. page_chain_for_each_safe(page, tmp) {
  107. put_page(page);
  108. ++i;
  109. }
  110. return i;
  111. }
  112. static void page_chain_add(struct page **head,
  113. struct page *chain_first, struct page *chain_last)
  114. {
  115. #if 1
  116. struct page *tmp;
  117. tmp = page_chain_tail(chain_first, NULL);
  118. BUG_ON(tmp != chain_last);
  119. #endif
  120. /* add chain to head */
  121. set_page_private(chain_last, (unsigned long)*head);
  122. *head = chain_first;
  123. }
  124. static struct page *drbd_pp_first_pages_or_try_alloc(struct drbd_conf *mdev, int number)
  125. {
  126. struct page *page = NULL;
  127. struct page *tmp = NULL;
  128. int i = 0;
  129. /* Yes, testing drbd_pp_vacant outside the lock is racy.
  130. * So what. It saves a spin_lock. */
  131. if (drbd_pp_vacant >= number) {
  132. spin_lock(&drbd_pp_lock);
  133. page = page_chain_del(&drbd_pp_pool, number);
  134. if (page)
  135. drbd_pp_vacant -= number;
  136. spin_unlock(&drbd_pp_lock);
  137. if (page)
  138. return page;
  139. }
  140. /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD
  141. * "criss-cross" setup, that might cause write-out on some other DRBD,
  142. * which in turn might block on the other node at this very place. */
  143. for (i = 0; i < number; i++) {
  144. tmp = alloc_page(GFP_TRY);
  145. if (!tmp)
  146. break;
  147. set_page_private(tmp, (unsigned long)page);
  148. page = tmp;
  149. }
  150. if (i == number)
  151. return page;
  152. /* Not enough pages immediately available this time.
  153. * No need to jump around here, drbd_pp_alloc will retry this
  154. * function "soon". */
  155. if (page) {
  156. tmp = page_chain_tail(page, NULL);
  157. spin_lock(&drbd_pp_lock);
  158. page_chain_add(&drbd_pp_pool, page, tmp);
  159. drbd_pp_vacant += i;
  160. spin_unlock(&drbd_pp_lock);
  161. }
  162. return NULL;
  163. }
  164. static void reclaim_net_ee(struct drbd_conf *mdev, struct list_head *to_be_freed)
  165. {
  166. struct drbd_peer_request *peer_req;
  167. struct list_head *le, *tle;
  168. /* The EEs are always appended to the end of the list. Since
  169. they are sent in order over the wire, they have to finish
  170. in order. As soon as we see the first not finished we can
  171. stop to examine the list... */
  172. list_for_each_safe(le, tle, &mdev->net_ee) {
  173. peer_req = list_entry(le, struct drbd_peer_request, w.list);
  174. if (drbd_ee_has_active_page(peer_req))
  175. break;
  176. list_move(le, to_be_freed);
  177. }
  178. }
  179. static void drbd_kick_lo_and_reclaim_net(struct drbd_conf *mdev)
  180. {
  181. LIST_HEAD(reclaimed);
  182. struct drbd_peer_request *peer_req, *t;
  183. spin_lock_irq(&mdev->tconn->req_lock);
  184. reclaim_net_ee(mdev, &reclaimed);
  185. spin_unlock_irq(&mdev->tconn->req_lock);
  186. list_for_each_entry_safe(peer_req, t, &reclaimed, w.list)
  187. drbd_free_net_ee(mdev, peer_req);
  188. }
  189. /**
  190. * drbd_pp_alloc() - Returns @number pages, retries forever (or until signalled)
  191. * @mdev: DRBD device.
  192. * @number: number of pages requested
  193. * @retry: whether to retry, if not enough pages are available right now
  194. *
  195. * Tries to allocate number pages, first from our own page pool, then from
  196. * the kernel, unless this allocation would exceed the max_buffers setting.
  197. * Possibly retry until DRBD frees sufficient pages somewhere else.
  198. *
  199. * Returns a page chain linked via page->private.
  200. */
  201. static struct page *drbd_pp_alloc(struct drbd_conf *mdev, unsigned number, bool retry)
  202. {
  203. struct page *page = NULL;
  204. DEFINE_WAIT(wait);
  205. /* Yes, we may run up to @number over max_buffers. If we
  206. * follow it strictly, the admin will get it wrong anyways. */
  207. if (atomic_read(&mdev->pp_in_use) < mdev->tconn->net_conf->max_buffers)
  208. page = drbd_pp_first_pages_or_try_alloc(mdev, number);
  209. while (page == NULL) {
  210. prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE);
  211. drbd_kick_lo_and_reclaim_net(mdev);
  212. if (atomic_read(&mdev->pp_in_use) < mdev->tconn->net_conf->max_buffers) {
  213. page = drbd_pp_first_pages_or_try_alloc(mdev, number);
  214. if (page)
  215. break;
  216. }
  217. if (!retry)
  218. break;
  219. if (signal_pending(current)) {
  220. dev_warn(DEV, "drbd_pp_alloc interrupted!\n");
  221. break;
  222. }
  223. schedule();
  224. }
  225. finish_wait(&drbd_pp_wait, &wait);
  226. if (page)
  227. atomic_add(number, &mdev->pp_in_use);
  228. return page;
  229. }
  230. /* Must not be used from irq, as that may deadlock: see drbd_pp_alloc.
  231. * Is also used from inside an other spin_lock_irq(&mdev->tconn->req_lock);
  232. * Either links the page chain back to the global pool,
  233. * or returns all pages to the system. */
  234. static void drbd_pp_free(struct drbd_conf *mdev, struct page *page, int is_net)
  235. {
  236. atomic_t *a = is_net ? &mdev->pp_in_use_by_net : &mdev->pp_in_use;
  237. int i;
  238. if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count)
  239. i = page_chain_free(page);
  240. else {
  241. struct page *tmp;
  242. tmp = page_chain_tail(page, &i);
  243. spin_lock(&drbd_pp_lock);
  244. page_chain_add(&drbd_pp_pool, page, tmp);
  245. drbd_pp_vacant += i;
  246. spin_unlock(&drbd_pp_lock);
  247. }
  248. i = atomic_sub_return(i, a);
  249. if (i < 0)
  250. dev_warn(DEV, "ASSERTION FAILED: %s: %d < 0\n",
  251. is_net ? "pp_in_use_by_net" : "pp_in_use", i);
  252. wake_up(&drbd_pp_wait);
  253. }
  254. /*
  255. You need to hold the req_lock:
  256. _drbd_wait_ee_list_empty()
  257. You must not have the req_lock:
  258. drbd_free_ee()
  259. drbd_alloc_ee()
  260. drbd_init_ee()
  261. drbd_release_ee()
  262. drbd_ee_fix_bhs()
  263. drbd_process_done_ee()
  264. drbd_clear_done_ee()
  265. drbd_wait_ee_list_empty()
  266. */
  267. struct drbd_peer_request *
  268. drbd_alloc_ee(struct drbd_conf *mdev, u64 id, sector_t sector,
  269. unsigned int data_size, gfp_t gfp_mask) __must_hold(local)
  270. {
  271. struct drbd_peer_request *peer_req;
  272. struct page *page;
  273. unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT;
  274. if (drbd_insert_fault(mdev, DRBD_FAULT_AL_EE))
  275. return NULL;
  276. peer_req = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM);
  277. if (!peer_req) {
  278. if (!(gfp_mask & __GFP_NOWARN))
  279. dev_err(DEV, "alloc_ee: Allocation of an EE failed\n");
  280. return NULL;
  281. }
  282. page = drbd_pp_alloc(mdev, nr_pages, (gfp_mask & __GFP_WAIT));
  283. if (!page)
  284. goto fail;
  285. drbd_clear_interval(&peer_req->i);
  286. peer_req->i.size = data_size;
  287. peer_req->i.sector = sector;
  288. peer_req->i.local = false;
  289. peer_req->i.waiting = false;
  290. peer_req->epoch = NULL;
  291. peer_req->w.mdev = mdev;
  292. peer_req->pages = page;
  293. atomic_set(&peer_req->pending_bios, 0);
  294. peer_req->flags = 0;
  295. /*
  296. * The block_id is opaque to the receiver. It is not endianness
  297. * converted, and sent back to the sender unchanged.
  298. */
  299. peer_req->block_id = id;
  300. return peer_req;
  301. fail:
  302. mempool_free(peer_req, drbd_ee_mempool);
  303. return NULL;
  304. }
  305. void drbd_free_some_ee(struct drbd_conf *mdev, struct drbd_peer_request *peer_req,
  306. int is_net)
  307. {
  308. if (peer_req->flags & EE_HAS_DIGEST)
  309. kfree(peer_req->digest);
  310. drbd_pp_free(mdev, peer_req->pages, is_net);
  311. D_ASSERT(atomic_read(&peer_req->pending_bios) == 0);
  312. D_ASSERT(drbd_interval_empty(&peer_req->i));
  313. mempool_free(peer_req, drbd_ee_mempool);
  314. }
  315. int drbd_release_ee(struct drbd_conf *mdev, struct list_head *list)
  316. {
  317. LIST_HEAD(work_list);
  318. struct drbd_peer_request *peer_req, *t;
  319. int count = 0;
  320. int is_net = list == &mdev->net_ee;
  321. spin_lock_irq(&mdev->tconn->req_lock);
  322. list_splice_init(list, &work_list);
  323. spin_unlock_irq(&mdev->tconn->req_lock);
  324. list_for_each_entry_safe(peer_req, t, &work_list, w.list) {
  325. drbd_free_some_ee(mdev, peer_req, is_net);
  326. count++;
  327. }
  328. return count;
  329. }
  330. /* See also comments in _req_mod(,BARRIER_ACKED)
  331. * and receive_Barrier.
  332. *
  333. * Move entries from net_ee to done_ee, if ready.
  334. * Grab done_ee, call all callbacks, free the entries.
  335. * The callbacks typically send out ACKs.
  336. */
  337. static int drbd_process_done_ee(struct drbd_conf *mdev)
  338. {
  339. LIST_HEAD(work_list);
  340. LIST_HEAD(reclaimed);
  341. struct drbd_peer_request *peer_req, *t;
  342. int err = 0;
  343. spin_lock_irq(&mdev->tconn->req_lock);
  344. reclaim_net_ee(mdev, &reclaimed);
  345. list_splice_init(&mdev->done_ee, &work_list);
  346. spin_unlock_irq(&mdev->tconn->req_lock);
  347. list_for_each_entry_safe(peer_req, t, &reclaimed, w.list)
  348. drbd_free_net_ee(mdev, peer_req);
  349. /* possible callbacks here:
  350. * e_end_block, and e_end_resync_block, e_send_discard_write.
  351. * all ignore the last argument.
  352. */
  353. list_for_each_entry_safe(peer_req, t, &work_list, w.list) {
  354. int err2;
  355. /* list_del not necessary, next/prev members not touched */
  356. err2 = peer_req->w.cb(&peer_req->w, !!err);
  357. if (!err)
  358. err = err2;
  359. drbd_free_ee(mdev, peer_req);
  360. }
  361. wake_up(&mdev->ee_wait);
  362. return err;
  363. }
  364. void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head)
  365. {
  366. DEFINE_WAIT(wait);
  367. /* avoids spin_lock/unlock
  368. * and calling prepare_to_wait in the fast path */
  369. while (!list_empty(head)) {
  370. prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE);
  371. spin_unlock_irq(&mdev->tconn->req_lock);
  372. io_schedule();
  373. finish_wait(&mdev->ee_wait, &wait);
  374. spin_lock_irq(&mdev->tconn->req_lock);
  375. }
  376. }
  377. void drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head)
  378. {
  379. spin_lock_irq(&mdev->tconn->req_lock);
  380. _drbd_wait_ee_list_empty(mdev, head);
  381. spin_unlock_irq(&mdev->tconn->req_lock);
  382. }
  383. /* see also kernel_accept; which is only present since 2.6.18.
  384. * also we want to log which part of it failed, exactly */
  385. static int drbd_accept(const char **what, struct socket *sock, struct socket **newsock)
  386. {
  387. struct sock *sk = sock->sk;
  388. int err = 0;
  389. *what = "listen";
  390. err = sock->ops->listen(sock, 5);
  391. if (err < 0)
  392. goto out;
  393. *what = "sock_create_lite";
  394. err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol,
  395. newsock);
  396. if (err < 0)
  397. goto out;
  398. *what = "accept";
  399. err = sock->ops->accept(sock, *newsock, 0);
  400. if (err < 0) {
  401. sock_release(*newsock);
  402. *newsock = NULL;
  403. goto out;
  404. }
  405. (*newsock)->ops = sock->ops;
  406. out:
  407. return err;
  408. }
  409. static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags)
  410. {
  411. mm_segment_t oldfs;
  412. struct kvec iov = {
  413. .iov_base = buf,
  414. .iov_len = size,
  415. };
  416. struct msghdr msg = {
  417. .msg_iovlen = 1,
  418. .msg_iov = (struct iovec *)&iov,
  419. .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL)
  420. };
  421. int rv;
  422. oldfs = get_fs();
  423. set_fs(KERNEL_DS);
  424. rv = sock_recvmsg(sock, &msg, size, msg.msg_flags);
  425. set_fs(oldfs);
  426. return rv;
  427. }
  428. static int drbd_recv(struct drbd_tconn *tconn, void *buf, size_t size)
  429. {
  430. mm_segment_t oldfs;
  431. struct kvec iov = {
  432. .iov_base = buf,
  433. .iov_len = size,
  434. };
  435. struct msghdr msg = {
  436. .msg_iovlen = 1,
  437. .msg_iov = (struct iovec *)&iov,
  438. .msg_flags = MSG_WAITALL | MSG_NOSIGNAL
  439. };
  440. int rv;
  441. oldfs = get_fs();
  442. set_fs(KERNEL_DS);
  443. for (;;) {
  444. rv = sock_recvmsg(tconn->data.socket, &msg, size, msg.msg_flags);
  445. if (rv == size)
  446. break;
  447. /* Note:
  448. * ECONNRESET other side closed the connection
  449. * ERESTARTSYS (on sock) we got a signal
  450. */
  451. if (rv < 0) {
  452. if (rv == -ECONNRESET)
  453. conn_info(tconn, "sock was reset by peer\n");
  454. else if (rv != -ERESTARTSYS)
  455. conn_err(tconn, "sock_recvmsg returned %d\n", rv);
  456. break;
  457. } else if (rv == 0) {
  458. conn_info(tconn, "sock was shut down by peer\n");
  459. break;
  460. } else {
  461. /* signal came in, or peer/link went down,
  462. * after we read a partial message
  463. */
  464. /* D_ASSERT(signal_pending(current)); */
  465. break;
  466. }
  467. };
  468. set_fs(oldfs);
  469. if (rv != size)
  470. conn_request_state(tconn, NS(conn, C_BROKEN_PIPE), CS_HARD);
  471. return rv;
  472. }
  473. static int drbd_recv_all(struct drbd_tconn *tconn, void *buf, size_t size)
  474. {
  475. int err;
  476. err = drbd_recv(tconn, buf, size);
  477. if (err != size) {
  478. if (err >= 0)
  479. err = -EIO;
  480. } else
  481. err = 0;
  482. return err;
  483. }
  484. static int drbd_recv_all_warn(struct drbd_tconn *tconn, void *buf, size_t size)
  485. {
  486. int err;
  487. err = drbd_recv_all(tconn, buf, size);
  488. if (err && !signal_pending(current))
  489. conn_warn(tconn, "short read (expected size %d)\n", (int)size);
  490. return err;
  491. }
  492. /* quoting tcp(7):
  493. * On individual connections, the socket buffer size must be set prior to the
  494. * listen(2) or connect(2) calls in order to have it take effect.
  495. * This is our wrapper to do so.
  496. */
  497. static void drbd_setbufsize(struct socket *sock, unsigned int snd,
  498. unsigned int rcv)
  499. {
  500. /* open coded SO_SNDBUF, SO_RCVBUF */
  501. if (snd) {
  502. sock->sk->sk_sndbuf = snd;
  503. sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
  504. }
  505. if (rcv) {
  506. sock->sk->sk_rcvbuf = rcv;
  507. sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
  508. }
  509. }
  510. static struct socket *drbd_try_connect(struct drbd_tconn *tconn)
  511. {
  512. const char *what;
  513. struct socket *sock;
  514. struct sockaddr_in6 src_in6;
  515. int err;
  516. int disconnect_on_error = 1;
  517. if (!get_net_conf(tconn))
  518. return NULL;
  519. what = "sock_create_kern";
  520. err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family,
  521. SOCK_STREAM, IPPROTO_TCP, &sock);
  522. if (err < 0) {
  523. sock = NULL;
  524. goto out;
  525. }
  526. sock->sk->sk_rcvtimeo =
  527. sock->sk->sk_sndtimeo = tconn->net_conf->try_connect_int*HZ;
  528. drbd_setbufsize(sock, tconn->net_conf->sndbuf_size,
  529. tconn->net_conf->rcvbuf_size);
  530. /* explicitly bind to the configured IP as source IP
  531. * for the outgoing connections.
  532. * This is needed for multihomed hosts and to be
  533. * able to use lo: interfaces for drbd.
  534. * Make sure to use 0 as port number, so linux selects
  535. * a free one dynamically.
  536. */
  537. memcpy(&src_in6, tconn->net_conf->my_addr,
  538. min_t(int, tconn->net_conf->my_addr_len, sizeof(src_in6)));
  539. if (((struct sockaddr *)tconn->net_conf->my_addr)->sa_family == AF_INET6)
  540. src_in6.sin6_port = 0;
  541. else
  542. ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */
  543. what = "bind before connect";
  544. err = sock->ops->bind(sock,
  545. (struct sockaddr *) &src_in6,
  546. tconn->net_conf->my_addr_len);
  547. if (err < 0)
  548. goto out;
  549. /* connect may fail, peer not yet available.
  550. * stay C_WF_CONNECTION, don't go Disconnecting! */
  551. disconnect_on_error = 0;
  552. what = "connect";
  553. err = sock->ops->connect(sock,
  554. (struct sockaddr *)tconn->net_conf->peer_addr,
  555. tconn->net_conf->peer_addr_len, 0);
  556. out:
  557. if (err < 0) {
  558. if (sock) {
  559. sock_release(sock);
  560. sock = NULL;
  561. }
  562. switch (-err) {
  563. /* timeout, busy, signal pending */
  564. case ETIMEDOUT: case EAGAIN: case EINPROGRESS:
  565. case EINTR: case ERESTARTSYS:
  566. /* peer not (yet) available, network problem */
  567. case ECONNREFUSED: case ENETUNREACH:
  568. case EHOSTDOWN: case EHOSTUNREACH:
  569. disconnect_on_error = 0;
  570. break;
  571. default:
  572. conn_err(tconn, "%s failed, err = %d\n", what, err);
  573. }
  574. if (disconnect_on_error)
  575. conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD);
  576. }
  577. put_net_conf(tconn);
  578. return sock;
  579. }
  580. static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn)
  581. {
  582. int timeo, err;
  583. struct socket *s_estab = NULL, *s_listen;
  584. const char *what;
  585. if (!get_net_conf(tconn))
  586. return NULL;
  587. what = "sock_create_kern";
  588. err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family,
  589. SOCK_STREAM, IPPROTO_TCP, &s_listen);
  590. if (err) {
  591. s_listen = NULL;
  592. goto out;
  593. }
  594. timeo = tconn->net_conf->try_connect_int * HZ;
  595. timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */
  596. s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */
  597. s_listen->sk->sk_rcvtimeo = timeo;
  598. s_listen->sk->sk_sndtimeo = timeo;
  599. drbd_setbufsize(s_listen, tconn->net_conf->sndbuf_size,
  600. tconn->net_conf->rcvbuf_size);
  601. what = "bind before listen";
  602. err = s_listen->ops->bind(s_listen,
  603. (struct sockaddr *) tconn->net_conf->my_addr,
  604. tconn->net_conf->my_addr_len);
  605. if (err < 0)
  606. goto out;
  607. err = drbd_accept(&what, s_listen, &s_estab);
  608. out:
  609. if (s_listen)
  610. sock_release(s_listen);
  611. if (err < 0) {
  612. if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) {
  613. conn_err(tconn, "%s failed, err = %d\n", what, err);
  614. conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD);
  615. }
  616. }
  617. put_net_conf(tconn);
  618. return s_estab;
  619. }
  620. static int drbd_send_fp(struct drbd_tconn *tconn, struct drbd_socket *sock, enum drbd_packet cmd)
  621. {
  622. struct p_header *h = tconn->data.sbuf;
  623. return !_conn_send_cmd(tconn, 0, sock, cmd, h, sizeof(*h), 0);
  624. }
  625. static enum drbd_packet drbd_recv_fp(struct drbd_tconn *tconn, struct socket *sock)
  626. {
  627. struct p_header80 h;
  628. int rr;
  629. rr = drbd_recv_short(sock, &h, sizeof(h), 0);
  630. if (rr == sizeof(h) && h.magic == cpu_to_be32(DRBD_MAGIC))
  631. return be16_to_cpu(h.command);
  632. return 0xffff;
  633. }
  634. /**
  635. * drbd_socket_okay() - Free the socket if its connection is not okay
  636. * @sock: pointer to the pointer to the socket.
  637. */
  638. static int drbd_socket_okay(struct socket **sock)
  639. {
  640. int rr;
  641. char tb[4];
  642. if (!*sock)
  643. return false;
  644. rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK);
  645. if (rr > 0 || rr == -EAGAIN) {
  646. return true;
  647. } else {
  648. sock_release(*sock);
  649. *sock = NULL;
  650. return false;
  651. }
  652. }
  653. /* Gets called if a connection is established, or if a new minor gets created
  654. in a connection */
  655. int drbd_connected(int vnr, void *p, void *data)
  656. {
  657. struct drbd_conf *mdev = (struct drbd_conf *)p;
  658. int err;
  659. atomic_set(&mdev->packet_seq, 0);
  660. mdev->peer_seq = 0;
  661. mdev->state_mutex = mdev->tconn->agreed_pro_version < 100 ?
  662. &mdev->tconn->cstate_mutex :
  663. &mdev->own_state_mutex;
  664. err = drbd_send_sync_param(mdev);
  665. if (!err)
  666. err = drbd_send_sizes(mdev, 0, 0);
  667. if (!err)
  668. err = drbd_send_uuids(mdev);
  669. if (!err)
  670. err = drbd_send_state(mdev);
  671. clear_bit(USE_DEGR_WFC_T, &mdev->flags);
  672. clear_bit(RESIZE_PENDING, &mdev->flags);
  673. return err;
  674. }
  675. /*
  676. * return values:
  677. * 1 yes, we have a valid connection
  678. * 0 oops, did not work out, please try again
  679. * -1 peer talks different language,
  680. * no point in trying again, please go standalone.
  681. * -2 We do not have a network config...
  682. */
  683. static int drbd_connect(struct drbd_tconn *tconn)
  684. {
  685. struct socket *sock, *msock;
  686. int try, h, ok;
  687. if (conn_request_state(tconn, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS)
  688. return -2;
  689. clear_bit(DISCARD_CONCURRENT, &tconn->flags);
  690. /* Assume that the peer only understands protocol 80 until we know better. */
  691. tconn->agreed_pro_version = 80;
  692. do {
  693. struct socket *s;
  694. for (try = 0;;) {
  695. /* 3 tries, this should take less than a second! */
  696. s = drbd_try_connect(tconn);
  697. if (s || ++try >= 3)
  698. break;
  699. /* give the other side time to call bind() & listen() */
  700. schedule_timeout_interruptible(HZ / 10);
  701. }
  702. if (s) {
  703. if (!tconn->data.socket) {
  704. tconn->data.socket = s;
  705. drbd_send_fp(tconn, &tconn->data, P_INITIAL_DATA);
  706. } else if (!tconn->meta.socket) {
  707. tconn->meta.socket = s;
  708. drbd_send_fp(tconn, &tconn->meta, P_INITIAL_META);
  709. } else {
  710. conn_err(tconn, "Logic error in drbd_connect()\n");
  711. goto out_release_sockets;
  712. }
  713. }
  714. if (tconn->data.socket && tconn->meta.socket) {
  715. schedule_timeout_interruptible(tconn->net_conf->ping_timeo*HZ/10);
  716. ok = drbd_socket_okay(&tconn->data.socket);
  717. ok = drbd_socket_okay(&tconn->meta.socket) && ok;
  718. if (ok)
  719. break;
  720. }
  721. retry:
  722. s = drbd_wait_for_connect(tconn);
  723. if (s) {
  724. try = drbd_recv_fp(tconn, s);
  725. drbd_socket_okay(&tconn->data.socket);
  726. drbd_socket_okay(&tconn->meta.socket);
  727. switch (try) {
  728. case P_INITIAL_DATA:
  729. if (tconn->data.socket) {
  730. conn_warn(tconn, "initial packet S crossed\n");
  731. sock_release(tconn->data.socket);
  732. }
  733. tconn->data.socket = s;
  734. break;
  735. case P_INITIAL_META:
  736. if (tconn->meta.socket) {
  737. conn_warn(tconn, "initial packet M crossed\n");
  738. sock_release(tconn->meta.socket);
  739. }
  740. tconn->meta.socket = s;
  741. set_bit(DISCARD_CONCURRENT, &tconn->flags);
  742. break;
  743. default:
  744. conn_warn(tconn, "Error receiving initial packet\n");
  745. sock_release(s);
  746. if (random32() & 1)
  747. goto retry;
  748. }
  749. }
  750. if (tconn->cstate <= C_DISCONNECTING)
  751. goto out_release_sockets;
  752. if (signal_pending(current)) {
  753. flush_signals(current);
  754. smp_rmb();
  755. if (get_t_state(&tconn->receiver) == EXITING)
  756. goto out_release_sockets;
  757. }
  758. if (tconn->data.socket && &tconn->meta.socket) {
  759. ok = drbd_socket_okay(&tconn->data.socket);
  760. ok = drbd_socket_okay(&tconn->meta.socket) && ok;
  761. if (ok)
  762. break;
  763. }
  764. } while (1);
  765. sock = tconn->data.socket;
  766. msock = tconn->meta.socket;
  767. msock->sk->sk_reuse = 1; /* SO_REUSEADDR */
  768. sock->sk->sk_reuse = 1; /* SO_REUSEADDR */
  769. sock->sk->sk_allocation = GFP_NOIO;
  770. msock->sk->sk_allocation = GFP_NOIO;
  771. sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK;
  772. msock->sk->sk_priority = TC_PRIO_INTERACTIVE;
  773. /* NOT YET ...
  774. * sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10;
  775. * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
  776. * first set it to the P_HAND_SHAKE timeout,
  777. * which we set to 4x the configured ping_timeout. */
  778. sock->sk->sk_sndtimeo =
  779. sock->sk->sk_rcvtimeo = tconn->net_conf->ping_timeo*4*HZ/10;
  780. msock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10;
  781. msock->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ;
  782. /* we don't want delays.
  783. * we use TCP_CORK where appropriate, though */
  784. drbd_tcp_nodelay(sock);
  785. drbd_tcp_nodelay(msock);
  786. tconn->last_received = jiffies;
  787. h = drbd_do_handshake(tconn);
  788. if (h <= 0)
  789. return h;
  790. if (tconn->cram_hmac_tfm) {
  791. /* drbd_request_state(mdev, NS(conn, WFAuth)); */
  792. switch (drbd_do_auth(tconn)) {
  793. case -1:
  794. conn_err(tconn, "Authentication of peer failed\n");
  795. return -1;
  796. case 0:
  797. conn_err(tconn, "Authentication of peer failed, trying again.\n");
  798. return 0;
  799. }
  800. }
  801. if (conn_request_state(tconn, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE) < SS_SUCCESS)
  802. return 0;
  803. sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10;
  804. sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
  805. drbd_thread_start(&tconn->asender);
  806. if (drbd_send_protocol(tconn) == -EOPNOTSUPP)
  807. return -1;
  808. return !idr_for_each(&tconn->volumes, drbd_connected, tconn);
  809. out_release_sockets:
  810. if (tconn->data.socket) {
  811. sock_release(tconn->data.socket);
  812. tconn->data.socket = NULL;
  813. }
  814. if (tconn->meta.socket) {
  815. sock_release(tconn->meta.socket);
  816. tconn->meta.socket = NULL;
  817. }
  818. return -1;
  819. }
  820. static int decode_header(struct drbd_tconn *tconn, struct p_header *h, struct packet_info *pi)
  821. {
  822. if (h->h80.magic == cpu_to_be32(DRBD_MAGIC)) {
  823. pi->cmd = be16_to_cpu(h->h80.command);
  824. pi->size = be16_to_cpu(h->h80.length);
  825. pi->vnr = 0;
  826. } else if (h->h95.magic == cpu_to_be16(DRBD_MAGIC_BIG)) {
  827. pi->cmd = be16_to_cpu(h->h95.command);
  828. pi->size = be32_to_cpu(h->h95.length) & 0x00ffffff;
  829. pi->vnr = 0;
  830. } else {
  831. conn_err(tconn, "magic?? on data m: 0x%08x c: %d l: %d\n",
  832. be32_to_cpu(h->h80.magic),
  833. be16_to_cpu(h->h80.command),
  834. be16_to_cpu(h->h80.length));
  835. return -EINVAL;
  836. }
  837. return 0;
  838. }
  839. static int drbd_recv_header(struct drbd_tconn *tconn, struct packet_info *pi)
  840. {
  841. struct p_header *h = tconn->data.rbuf;
  842. int err;
  843. err = drbd_recv_all_warn(tconn, h, sizeof(*h));
  844. if (err)
  845. return err;
  846. err = decode_header(tconn, h, pi);
  847. tconn->last_received = jiffies;
  848. return err;
  849. }
  850. static void drbd_flush(struct drbd_conf *mdev)
  851. {
  852. int rv;
  853. if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) {
  854. rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL,
  855. NULL);
  856. if (rv) {
  857. dev_err(DEV, "local disk flush failed with status %d\n", rv);
  858. /* would rather check on EOPNOTSUPP, but that is not reliable.
  859. * don't try again for ANY return value != 0
  860. * if (rv == -EOPNOTSUPP) */
  861. drbd_bump_write_ordering(mdev, WO_drain_io);
  862. }
  863. put_ldev(mdev);
  864. }
  865. }
  866. /**
  867. * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it.
  868. * @mdev: DRBD device.
  869. * @epoch: Epoch object.
  870. * @ev: Epoch event.
  871. */
  872. static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev,
  873. struct drbd_epoch *epoch,
  874. enum epoch_event ev)
  875. {
  876. int epoch_size;
  877. struct drbd_epoch *next_epoch;
  878. enum finish_epoch rv = FE_STILL_LIVE;
  879. spin_lock(&mdev->epoch_lock);
  880. do {
  881. next_epoch = NULL;
  882. epoch_size = atomic_read(&epoch->epoch_size);
  883. switch (ev & ~EV_CLEANUP) {
  884. case EV_PUT:
  885. atomic_dec(&epoch->active);
  886. break;
  887. case EV_GOT_BARRIER_NR:
  888. set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags);
  889. break;
  890. case EV_BECAME_LAST:
  891. /* nothing to do*/
  892. break;
  893. }
  894. if (epoch_size != 0 &&
  895. atomic_read(&epoch->active) == 0 &&
  896. test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) {
  897. if (!(ev & EV_CLEANUP)) {
  898. spin_unlock(&mdev->epoch_lock);
  899. drbd_send_b_ack(mdev, epoch->barrier_nr, epoch_size);
  900. spin_lock(&mdev->epoch_lock);
  901. }
  902. dec_unacked(mdev);
  903. if (mdev->current_epoch != epoch) {
  904. next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list);
  905. list_del(&epoch->list);
  906. ev = EV_BECAME_LAST | (ev & EV_CLEANUP);
  907. mdev->epochs--;
  908. kfree(epoch);
  909. if (rv == FE_STILL_LIVE)
  910. rv = FE_DESTROYED;
  911. } else {
  912. epoch->flags = 0;
  913. atomic_set(&epoch->epoch_size, 0);
  914. /* atomic_set(&epoch->active, 0); is already zero */
  915. if (rv == FE_STILL_LIVE)
  916. rv = FE_RECYCLED;
  917. wake_up(&mdev->ee_wait);
  918. }
  919. }
  920. if (!next_epoch)
  921. break;
  922. epoch = next_epoch;
  923. } while (1);
  924. spin_unlock(&mdev->epoch_lock);
  925. return rv;
  926. }
  927. /**
  928. * drbd_bump_write_ordering() - Fall back to an other write ordering method
  929. * @mdev: DRBD device.
  930. * @wo: Write ordering method to try.
  931. */
  932. void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo) __must_hold(local)
  933. {
  934. enum write_ordering_e pwo;
  935. static char *write_ordering_str[] = {
  936. [WO_none] = "none",
  937. [WO_drain_io] = "drain",
  938. [WO_bdev_flush] = "flush",
  939. };
  940. pwo = mdev->write_ordering;
  941. wo = min(pwo, wo);
  942. if (wo == WO_bdev_flush && mdev->ldev->dc.no_disk_flush)
  943. wo = WO_drain_io;
  944. if (wo == WO_drain_io && mdev->ldev->dc.no_disk_drain)
  945. wo = WO_none;
  946. mdev->write_ordering = wo;
  947. if (pwo != mdev->write_ordering || wo == WO_bdev_flush)
  948. dev_info(DEV, "Method to ensure write ordering: %s\n", write_ordering_str[mdev->write_ordering]);
  949. }
  950. /**
  951. * drbd_submit_peer_request()
  952. * @mdev: DRBD device.
  953. * @peer_req: peer request
  954. * @rw: flag field, see bio->bi_rw
  955. *
  956. * May spread the pages to multiple bios,
  957. * depending on bio_add_page restrictions.
  958. *
  959. * Returns 0 if all bios have been submitted,
  960. * -ENOMEM if we could not allocate enough bios,
  961. * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a
  962. * single page to an empty bio (which should never happen and likely indicates
  963. * that the lower level IO stack is in some way broken). This has been observed
  964. * on certain Xen deployments.
  965. */
  966. /* TODO allocate from our own bio_set. */
  967. int drbd_submit_peer_request(struct drbd_conf *mdev,
  968. struct drbd_peer_request *peer_req,
  969. const unsigned rw, const int fault_type)
  970. {
  971. struct bio *bios = NULL;
  972. struct bio *bio;
  973. struct page *page = peer_req->pages;
  974. sector_t sector = peer_req->i.sector;
  975. unsigned ds = peer_req->i.size;
  976. unsigned n_bios = 0;
  977. unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT;
  978. int err = -ENOMEM;
  979. /* In most cases, we will only need one bio. But in case the lower
  980. * level restrictions happen to be different at this offset on this
  981. * side than those of the sending peer, we may need to submit the
  982. * request in more than one bio.
  983. *
  984. * Plain bio_alloc is good enough here, this is no DRBD internally
  985. * generated bio, but a bio allocated on behalf of the peer.
  986. */
  987. next_bio:
  988. bio = bio_alloc(GFP_NOIO, nr_pages);
  989. if (!bio) {
  990. dev_err(DEV, "submit_ee: Allocation of a bio failed\n");
  991. goto fail;
  992. }
  993. /* > peer_req->i.sector, unless this is the first bio */
  994. bio->bi_sector = sector;
  995. bio->bi_bdev = mdev->ldev->backing_bdev;
  996. bio->bi_rw = rw;
  997. bio->bi_private = peer_req;
  998. bio->bi_end_io = drbd_peer_request_endio;
  999. bio->bi_next = bios;
  1000. bios = bio;
  1001. ++n_bios;
  1002. page_chain_for_each(page) {
  1003. unsigned len = min_t(unsigned, ds, PAGE_SIZE);
  1004. if (!bio_add_page(bio, page, len, 0)) {
  1005. /* A single page must always be possible!
  1006. * But in case it fails anyways,
  1007. * we deal with it, and complain (below). */
  1008. if (bio->bi_vcnt == 0) {
  1009. dev_err(DEV,
  1010. "bio_add_page failed for len=%u, "
  1011. "bi_vcnt=0 (bi_sector=%llu)\n",
  1012. len, (unsigned long long)bio->bi_sector);
  1013. err = -ENOSPC;
  1014. goto fail;
  1015. }
  1016. goto next_bio;
  1017. }
  1018. ds -= len;
  1019. sector += len >> 9;
  1020. --nr_pages;
  1021. }
  1022. D_ASSERT(page == NULL);
  1023. D_ASSERT(ds == 0);
  1024. atomic_set(&peer_req->pending_bios, n_bios);
  1025. do {
  1026. bio = bios;
  1027. bios = bios->bi_next;
  1028. bio->bi_next = NULL;
  1029. drbd_generic_make_request(mdev, fault_type, bio);
  1030. } while (bios);
  1031. return 0;
  1032. fail:
  1033. while (bios) {
  1034. bio = bios;
  1035. bios = bios->bi_next;
  1036. bio_put(bio);
  1037. }
  1038. return err;
  1039. }
  1040. static void drbd_remove_epoch_entry_interval(struct drbd_conf *mdev,
  1041. struct drbd_peer_request *peer_req)
  1042. {
  1043. struct drbd_interval *i = &peer_req->i;
  1044. drbd_remove_interval(&mdev->write_requests, i);
  1045. drbd_clear_interval(i);
  1046. /* Wake up any processes waiting for this peer request to complete. */
  1047. if (i->waiting)
  1048. wake_up(&mdev->misc_wait);
  1049. }
  1050. static int receive_Barrier(struct drbd_tconn *tconn, struct packet_info *pi)
  1051. {
  1052. struct drbd_conf *mdev;
  1053. int rv;
  1054. struct p_barrier *p = tconn->data.rbuf;
  1055. struct drbd_epoch *epoch;
  1056. mdev = vnr_to_mdev(tconn, pi->vnr);
  1057. if (!mdev)
  1058. return -EIO;
  1059. inc_unacked(mdev);
  1060. mdev->current_epoch->barrier_nr = p->barrier;
  1061. rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR);
  1062. /* P_BARRIER_ACK may imply that the corresponding extent is dropped from
  1063. * the activity log, which means it would not be resynced in case the
  1064. * R_PRIMARY crashes now.
  1065. * Therefore we must send the barrier_ack after the barrier request was
  1066. * completed. */
  1067. switch (mdev->write_ordering) {
  1068. case WO_none:
  1069. if (rv == FE_RECYCLED)
  1070. return 0;
  1071. /* receiver context, in the writeout path of the other node.
  1072. * avoid potential distributed deadlock */
  1073. epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO);
  1074. if (epoch)
  1075. break;
  1076. else
  1077. dev_warn(DEV, "Allocation of an epoch failed, slowing down\n");
  1078. /* Fall through */
  1079. case WO_bdev_flush:
  1080. case WO_drain_io:
  1081. drbd_wait_ee_list_empty(mdev, &mdev->active_ee);
  1082. drbd_flush(mdev);
  1083. if (atomic_read(&mdev->current_epoch->epoch_size)) {
  1084. epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO);
  1085. if (epoch)
  1086. break;
  1087. }
  1088. epoch = mdev->current_epoch;
  1089. wait_event(mdev->ee_wait, atomic_read(&epoch->epoch_size) == 0);
  1090. D_ASSERT(atomic_read(&epoch->active) == 0);
  1091. D_ASSERT(epoch->flags == 0);
  1092. return 0;
  1093. default:
  1094. dev_err(DEV, "Strangeness in mdev->write_ordering %d\n", mdev->write_ordering);
  1095. return -EIO;
  1096. }
  1097. epoch->flags = 0;
  1098. atomic_set(&epoch->epoch_size, 0);
  1099. atomic_set(&epoch->active, 0);
  1100. spin_lock(&mdev->epoch_lock);
  1101. if (atomic_read(&mdev->current_epoch->epoch_size)) {
  1102. list_add(&epoch->list, &mdev->current_epoch->list);
  1103. mdev->current_epoch = epoch;
  1104. mdev->epochs++;
  1105. } else {
  1106. /* The current_epoch got recycled while we allocated this one... */
  1107. kfree(epoch);
  1108. }
  1109. spin_unlock(&mdev->epoch_lock);
  1110. return 0;
  1111. }
  1112. /* used from receive_RSDataReply (recv_resync_read)
  1113. * and from receive_Data */
  1114. static struct drbd_peer_request *
  1115. read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector,
  1116. int data_size) __must_hold(local)
  1117. {
  1118. const sector_t capacity = drbd_get_capacity(mdev->this_bdev);
  1119. struct drbd_peer_request *peer_req;
  1120. struct page *page;
  1121. int dgs, ds, err;
  1122. void *dig_in = mdev->tconn->int_dig_in;
  1123. void *dig_vv = mdev->tconn->int_dig_vv;
  1124. unsigned long *data;
  1125. dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ?
  1126. crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0;
  1127. if (dgs) {
  1128. err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs);
  1129. if (err)
  1130. return NULL;
  1131. }
  1132. data_size -= dgs;
  1133. if (!expect(data_size != 0))
  1134. return NULL;
  1135. if (!expect(IS_ALIGNED(data_size, 512)))
  1136. return NULL;
  1137. if (!expect(data_size <= DRBD_MAX_BIO_SIZE))
  1138. return NULL;
  1139. /* even though we trust out peer,
  1140. * we sometimes have to double check. */
  1141. if (sector + (data_size>>9) > capacity) {
  1142. dev_err(DEV, "request from peer beyond end of local disk: "
  1143. "capacity: %llus < sector: %llus + size: %u\n",
  1144. (unsigned long long)capacity,
  1145. (unsigned long long)sector, data_size);
  1146. return NULL;
  1147. }
  1148. /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD
  1149. * "criss-cross" setup, that might cause write-out on some other DRBD,
  1150. * which in turn might block on the other node at this very place. */
  1151. peer_req = drbd_alloc_ee(mdev, id, sector, data_size, GFP_NOIO);
  1152. if (!peer_req)
  1153. return NULL;
  1154. ds = data_size;
  1155. page = peer_req->pages;
  1156. page_chain_for_each(page) {
  1157. unsigned len = min_t(int, ds, PAGE_SIZE);
  1158. data = kmap(page);
  1159. err = drbd_recv_all_warn(mdev->tconn, data, len);
  1160. if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) {
  1161. dev_err(DEV, "Fault injection: Corrupting data on receive\n");
  1162. data[0] = data[0] ^ (unsigned long)-1;
  1163. }
  1164. kunmap(page);
  1165. if (err) {
  1166. drbd_free_ee(mdev, peer_req);
  1167. return NULL;
  1168. }
  1169. ds -= len;
  1170. }
  1171. if (dgs) {
  1172. drbd_csum_ee(mdev, mdev->tconn->integrity_r_tfm, peer_req, dig_vv);
  1173. if (memcmp(dig_in, dig_vv, dgs)) {
  1174. dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n",
  1175. (unsigned long long)sector, data_size);
  1176. drbd_free_ee(mdev, peer_req);
  1177. return NULL;
  1178. }
  1179. }
  1180. mdev->recv_cnt += data_size>>9;
  1181. return peer_req;
  1182. }
  1183. /* drbd_drain_block() just takes a data block
  1184. * out of the socket input buffer, and discards it.
  1185. */
  1186. static int drbd_drain_block(struct drbd_conf *mdev, int data_size)
  1187. {
  1188. struct page *page;
  1189. int err = 0;
  1190. void *data;
  1191. if (!data_size)
  1192. return 0;
  1193. page = drbd_pp_alloc(mdev, 1, 1);
  1194. data = kmap(page);
  1195. while (data_size) {
  1196. unsigned int len = min_t(int, data_size, PAGE_SIZE);
  1197. err = drbd_recv_all_warn(mdev->tconn, data, len);
  1198. if (err)
  1199. break;
  1200. data_size -= len;
  1201. }
  1202. kunmap(page);
  1203. drbd_pp_free(mdev, page, 0);
  1204. return err;
  1205. }
  1206. static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req,
  1207. sector_t sector, int data_size)
  1208. {
  1209. struct bio_vec *bvec;
  1210. struct bio *bio;
  1211. int dgs, err, i, expect;
  1212. void *dig_in = mdev->tconn->int_dig_in;
  1213. void *dig_vv = mdev->tconn->int_dig_vv;
  1214. dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ?
  1215. crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0;
  1216. if (dgs) {
  1217. err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs);
  1218. if (err)
  1219. return err;
  1220. }
  1221. data_size -= dgs;
  1222. /* optimistically update recv_cnt. if receiving fails below,
  1223. * we disconnect anyways, and counters will be reset. */
  1224. mdev->recv_cnt += data_size>>9;
  1225. bio = req->master_bio;
  1226. D_ASSERT(sector == bio->bi_sector);
  1227. bio_for_each_segment(bvec, bio, i) {
  1228. void *mapped = kmap(bvec->bv_page) + bvec->bv_offset;
  1229. expect = min_t(int, data_size, bvec->bv_len);
  1230. err = drbd_recv_all_warn(mdev->tconn, mapped, expect);
  1231. kunmap(bvec->bv_page);
  1232. if (err)
  1233. return err;
  1234. data_size -= expect;
  1235. }
  1236. if (dgs) {
  1237. drbd_csum_bio(mdev, mdev->tconn->integrity_r_tfm, bio, dig_vv);
  1238. if (memcmp(dig_in, dig_vv, dgs)) {
  1239. dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n");
  1240. return -EINVAL;
  1241. }
  1242. }
  1243. D_ASSERT(data_size == 0);
  1244. return 0;
  1245. }
  1246. /* e_end_resync_block() is called via
  1247. * drbd_process_done_ee() by asender only */
  1248. static int e_end_resync_block(struct drbd_work *w, int unused)
  1249. {
  1250. struct drbd_peer_request *peer_req =
  1251. container_of(w, struct drbd_peer_request, w);
  1252. struct drbd_conf *mdev = w->mdev;
  1253. sector_t sector = peer_req->i.sector;
  1254. int err;
  1255. D_ASSERT(drbd_interval_empty(&peer_req->i));
  1256. if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) {
  1257. drbd_set_in_sync(mdev, sector, peer_req->i.size);
  1258. err = drbd_send_ack(mdev, P_RS_WRITE_ACK, peer_req);
  1259. } else {
  1260. /* Record failure to sync */
  1261. drbd_rs_failed_io(mdev, sector, peer_req->i.size);
  1262. err = drbd_send_ack(mdev, P_NEG_ACK, peer_req);
  1263. }
  1264. dec_unacked(mdev);
  1265. return err;
  1266. }
  1267. static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local)
  1268. {
  1269. struct drbd_peer_request *peer_req;
  1270. peer_req = read_in_block(mdev, ID_SYNCER, sector, data_size);
  1271. if (!peer_req)
  1272. goto fail;
  1273. dec_rs_pending(mdev);
  1274. inc_unacked(mdev);
  1275. /* corresponding dec_unacked() in e_end_resync_block()
  1276. * respective _drbd_clear_done_ee */
  1277. peer_req->w.cb = e_end_resync_block;
  1278. spin_lock_irq(&mdev->tconn->req_lock);
  1279. list_add(&peer_req->w.list, &mdev->sync_ee);
  1280. spin_unlock_irq(&mdev->tconn->req_lock);
  1281. atomic_add(data_size >> 9, &mdev->rs_sect_ev);
  1282. if (drbd_submit_peer_request(mdev, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0)
  1283. return 0;
  1284. /* don't care for the reason here */
  1285. dev_err(DEV, "submit failed, triggering re-connect\n");
  1286. spin_lock_irq(&mdev->tconn->req_lock);
  1287. list_del(&peer_req->w.list);
  1288. spin_unlock_irq(&mdev->tconn->req_lock);
  1289. drbd_free_ee(mdev, peer_req);
  1290. fail:
  1291. put_ldev(mdev);
  1292. return -EIO;
  1293. }
  1294. static struct drbd_request *
  1295. find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id,
  1296. sector_t sector, bool missing_ok, const char *func)
  1297. {
  1298. struct drbd_request *req;
  1299. /* Request object according to our peer */
  1300. req = (struct drbd_request *)(unsigned long)id;
  1301. if (drbd_contains_interval(root, sector, &req->i) && req->i.local)
  1302. return req;
  1303. if (!missing_ok) {
  1304. dev_err(DEV, "%s: failed to find request %lu, sector %llus\n", func,
  1305. (unsigned long)id, (unsigned long long)sector);
  1306. }
  1307. return NULL;
  1308. }
  1309. static int receive_DataReply(struct drbd_tconn *tconn, struct packet_info *pi)
  1310. {
  1311. struct drbd_conf *mdev;
  1312. struct drbd_request *req;
  1313. sector_t sector;
  1314. int err;
  1315. struct p_data *p = tconn->data.rbuf;
  1316. mdev = vnr_to_mdev(tconn, pi->vnr);
  1317. if (!mdev)
  1318. return -EIO;
  1319. sector = be64_to_cpu(p->sector);
  1320. spin_lock_irq(&mdev->tconn->req_lock);
  1321. req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__);
  1322. spin_unlock_irq(&mdev->tconn->req_lock);
  1323. if (unlikely(!req))
  1324. return -EIO;
  1325. /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid
  1326. * special casing it there for the various failure cases.
  1327. * still no race with drbd_fail_pending_reads */
  1328. err = recv_dless_read(mdev, req, sector, pi->size);
  1329. if (!err)
  1330. req_mod(req, DATA_RECEIVED);
  1331. /* else: nothing. handled from drbd_disconnect...
  1332. * I don't think we may complete this just yet
  1333. * in case we are "on-disconnect: freeze" */
  1334. return err;
  1335. }
  1336. static int receive_RSDataReply(struct drbd_tconn *tconn, struct packet_info *pi)
  1337. {
  1338. struct drbd_conf *mdev;
  1339. sector_t sector;
  1340. int err;
  1341. struct p_data *p = tconn->data.rbuf;
  1342. mdev = vnr_to_mdev(tconn, pi->vnr);
  1343. if (!mdev)
  1344. return -EIO;
  1345. sector = be64_to_cpu(p->sector);
  1346. D_ASSERT(p->block_id == ID_SYNCER);
  1347. if (get_ldev(mdev)) {
  1348. /* data is submitted to disk within recv_resync_read.
  1349. * corresponding put_ldev done below on error,
  1350. * or in drbd_peer_request_endio. */
  1351. err = recv_resync_read(mdev, sector, pi->size);
  1352. } else {
  1353. if (__ratelimit(&drbd_ratelimit_state))
  1354. dev_err(DEV, "Can not write resync data to local disk.\n");
  1355. err = drbd_drain_block(mdev, pi->size);
  1356. drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size);
  1357. }
  1358. atomic_add(pi->size >> 9, &mdev->rs_sect_in);
  1359. return err;
  1360. }
  1361. static int w_restart_write(struct drbd_work *w, int cancel)
  1362. {
  1363. struct drbd_request *req = container_of(w, struct drbd_request, w);
  1364. struct drbd_conf *mdev = w->mdev;
  1365. struct bio *bio;
  1366. unsigned long start_time;
  1367. unsigned long flags;
  1368. spin_lock_irqsave(&mdev->tconn->req_lock, flags);
  1369. if (!expect(req->rq_state & RQ_POSTPONED)) {
  1370. spin_unlock_irqrestore(&mdev->tconn->req_lock, flags);
  1371. return -EIO;
  1372. }
  1373. bio = req->master_bio;
  1374. start_time = req->start_time;
  1375. /* Postponed requests will not have their master_bio completed! */
  1376. __req_mod(req, DISCARD_WRITE, NULL);
  1377. spin_unlock_irqrestore(&mdev->tconn->req_lock, flags);
  1378. while (__drbd_make_request(mdev, bio, start_time))
  1379. /* retry */ ;
  1380. return 0;
  1381. }
  1382. static void restart_conflicting_writes(struct drbd_conf *mdev,
  1383. sector_t sector, int size)
  1384. {
  1385. struct drbd_interval *i;
  1386. struct drbd_request *req;
  1387. drbd_for_each_overlap(i, &mdev->write_requests, sector, size) {
  1388. if (!i->local)
  1389. continue;
  1390. req = container_of(i, struct drbd_request, i);
  1391. if (req->rq_state & RQ_LOCAL_PENDING ||
  1392. !(req->rq_state & RQ_POSTPONED))
  1393. continue;
  1394. if (expect(list_empty(&req->w.list))) {
  1395. req->w.mdev = mdev;
  1396. req->w.cb = w_restart_write;
  1397. drbd_queue_work(&mdev->tconn->data.work, &req->w);
  1398. }
  1399. }
  1400. }
  1401. /* e_end_block() is called via drbd_process_done_ee().
  1402. * this means this function only runs in the asender thread
  1403. */
  1404. static int e_end_block(struct drbd_work *w, int cancel)
  1405. {
  1406. struct drbd_peer_request *peer_req =
  1407. container_of(w, struct drbd_peer_request, w);
  1408. struct drbd_conf *mdev = w->mdev;
  1409. sector_t sector = peer_req->i.sector;
  1410. int err = 0, pcmd;
  1411. if (mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C) {
  1412. if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) {
  1413. pcmd = (mdev->state.conn >= C_SYNC_SOURCE &&
  1414. mdev->state.conn <= C_PAUSED_SYNC_T &&
  1415. peer_req->flags & EE_MAY_SET_IN_SYNC) ?
  1416. P_RS_WRITE_ACK : P_WRITE_ACK;
  1417. err = drbd_send_ack(mdev, pcmd, peer_req);
  1418. if (pcmd == P_RS_WRITE_ACK)
  1419. drbd_set_in_sync(mdev, sector, peer_req->i.size);
  1420. } else {
  1421. err = drbd_send_ack(mdev, P_NEG_ACK, peer_req);
  1422. /* we expect it to be marked out of sync anyways...
  1423. * maybe assert this? */
  1424. }
  1425. dec_unacked(mdev);
  1426. }
  1427. /* we delete from the conflict detection hash _after_ we sent out the
  1428. * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */
  1429. if (mdev->tconn->net_conf->two_primaries) {
  1430. spin_lock_irq(&mdev->tconn->req_lock);
  1431. D_ASSERT(!drbd_interval_empty(&peer_req->i));
  1432. drbd_remove_epoch_entry_interval(mdev, peer_req);
  1433. if (peer_req->flags & EE_RESTART_REQUESTS)
  1434. restart_conflicting_writes(mdev, sector, peer_req->i.size);
  1435. spin_unlock_irq(&mdev->tconn->req_lock);
  1436. } else
  1437. D_ASSERT(drbd_interval_empty(&peer_req->i));
  1438. drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0));
  1439. return err;
  1440. }
  1441. static int e_send_ack(struct drbd_work *w, enum drbd_packet ack)
  1442. {
  1443. struct drbd_conf *mdev = w->mdev;
  1444. struct drbd_peer_request *peer_req =
  1445. container_of(w, struct drbd_peer_request, w);
  1446. int err;
  1447. err = drbd_send_ack(mdev, ack, peer_req);
  1448. dec_unacked(mdev);
  1449. return err;
  1450. }
  1451. static int e_send_discard_write(struct drbd_work *w, int unused)
  1452. {
  1453. return e_send_ack(w, P_DISCARD_WRITE);
  1454. }
  1455. static int e_send_retry_write(struct drbd_work *w, int unused)
  1456. {
  1457. struct drbd_tconn *tconn = w->mdev->tconn;
  1458. return e_send_ack(w, tconn->agreed_pro_version >= 100 ?
  1459. P_RETRY_WRITE : P_DISCARD_WRITE);
  1460. }
  1461. static bool seq_greater(u32 a, u32 b)
  1462. {
  1463. /*
  1464. * We assume 32-bit wrap-around here.
  1465. * For 24-bit wrap-around, we would have to shift:
  1466. * a <<= 8; b <<= 8;
  1467. */
  1468. return (s32)a - (s32)b > 0;
  1469. }
  1470. static u32 seq_max(u32 a, u32 b)
  1471. {
  1472. return seq_greater(a, b) ? a : b;
  1473. }
  1474. static bool need_peer_seq(struct drbd_conf *mdev)
  1475. {
  1476. struct drbd_tconn *tconn = mdev->tconn;
  1477. /*
  1478. * We only need to keep track of the last packet_seq number of our peer
  1479. * if we are in dual-primary mode and we have the discard flag set; see
  1480. * handle_write_conflicts().
  1481. */
  1482. return tconn->net_conf->two_primaries &&
  1483. test_bit(DISCARD_CONCURRENT, &tconn->flags);
  1484. }
  1485. static void update_peer_seq(struct drbd_conf *mdev, unsigned int peer_seq)
  1486. {
  1487. unsigned int newest_peer_seq;
  1488. if (need_peer_seq(mdev)) {
  1489. spin_lock(&mdev->peer_seq_lock);
  1490. newest_peer_seq = seq_max(mdev->peer_seq, peer_seq);
  1491. mdev->peer_seq = newest_peer_seq;
  1492. spin_unlock(&mdev->peer_seq_lock);
  1493. /* wake up only if we actually changed mdev->peer_seq */
  1494. if (peer_seq == newest_peer_seq)
  1495. wake_up(&mdev->seq_wait);
  1496. }
  1497. }
  1498. /* Called from receive_Data.
  1499. * Synchronize packets on sock with packets on msock.
  1500. *
  1501. * This is here so even when a P_DATA packet traveling via sock overtook an Ack
  1502. * packet traveling on msock, they are still processed in the order they have
  1503. * been sent.
  1504. *
  1505. * Note: we don't care for Ack packets overtaking P_DATA packets.
  1506. *
  1507. * In case packet_seq is larger than mdev->peer_seq number, there are
  1508. * outstanding packets on the msock. We wait for them to arrive.
  1509. * In case we are the logically next packet, we update mdev->peer_seq
  1510. * ourselves. Correctly handles 32bit wrap around.
  1511. *
  1512. * Assume we have a 10 GBit connection, that is about 1<<30 byte per second,
  1513. * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds
  1514. * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have
  1515. * 1<<9 == 512 seconds aka ages for the 32bit wrap around...
  1516. *
  1517. * returns 0 if we may process the packet,
  1518. * -ERESTARTSYS if we were interrupted (by disconnect signal). */
  1519. static int wait_for_and_update_peer_seq(struct drbd_conf *mdev, const u32 peer_seq)
  1520. {
  1521. DEFINE_WAIT(wait);
  1522. long timeout;
  1523. int ret;
  1524. if (!need_peer_seq(mdev))
  1525. return 0;
  1526. spin_lock(&mdev->peer_seq_lock);
  1527. for (;;) {
  1528. if (!seq_greater(peer_seq - 1, mdev->peer_seq)) {
  1529. mdev->peer_seq = seq_max(mdev->peer_seq, peer_seq);
  1530. ret = 0;
  1531. break;
  1532. }
  1533. if (signal_pending(current)) {
  1534. ret = -ERESTARTSYS;
  1535. break;
  1536. }
  1537. prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE);
  1538. spin_unlock(&mdev->peer_seq_lock);
  1539. timeout = mdev->tconn->net_conf->ping_timeo*HZ/10;
  1540. timeout = schedule_timeout(timeout);
  1541. spin_lock(&mdev->peer_seq_lock);
  1542. if (!timeout) {
  1543. ret = -ETIMEDOUT;
  1544. dev_err(DEV, "Timed out waiting for missing ack packets; disconnecting\n");
  1545. break;
  1546. }
  1547. }
  1548. spin_unlock(&mdev->peer_seq_lock);
  1549. finish_wait(&mdev->seq_wait, &wait);
  1550. return ret;
  1551. }
  1552. /* see also bio_flags_to_wire()
  1553. * DRBD_REQ_*, because we need to semantically map the flags to data packet
  1554. * flags and back. We may replicate to other kernel versions. */
  1555. static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf)
  1556. {
  1557. return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) |
  1558. (dpf & DP_FUA ? REQ_FUA : 0) |
  1559. (dpf & DP_FLUSH ? REQ_FLUSH : 0) |
  1560. (dpf & DP_DISCARD ? REQ_DISCARD : 0);
  1561. }
  1562. static void fail_postponed_requests(struct drbd_conf *mdev, sector_t sector,
  1563. unsigned int size)
  1564. {
  1565. struct drbd_interval *i;
  1566. repeat:
  1567. drbd_for_each_overlap(i, &mdev->write_requests, sector, size) {
  1568. struct drbd_request *req;
  1569. struct bio_and_error m;
  1570. if (!i->local)
  1571. continue;
  1572. req = container_of(i, struct drbd_request, i);
  1573. if (!(req->rq_state & RQ_POSTPONED))
  1574. continue;
  1575. req->rq_state &= ~RQ_POSTPONED;
  1576. __req_mod(req, NEG_ACKED, &m);
  1577. spin_unlock_irq(&mdev->tconn->req_lock);
  1578. if (m.bio)
  1579. complete_master_bio(mdev, &m);
  1580. spin_lock_irq(&mdev->tconn->req_lock);
  1581. goto repeat;
  1582. }
  1583. }
  1584. static int handle_write_conflicts(struct drbd_conf *mdev,
  1585. struct drbd_peer_request *peer_req)
  1586. {
  1587. struct drbd_tconn *tconn = mdev->tconn;
  1588. bool resolve_conflicts = test_bit(DISCARD_CONCURRENT, &tconn->flags);
  1589. sector_t sector = peer_req->i.sector;
  1590. const unsigned int size = peer_req->i.size;
  1591. struct drbd_interval *i;
  1592. bool equal;
  1593. int err;
  1594. /*
  1595. * Inserting the peer request into the write_requests tree will prevent
  1596. * new conflicting local requests from being added.
  1597. */
  1598. drbd_insert_interval(&mdev->write_requests, &peer_req->i);
  1599. repeat:
  1600. drbd_for_each_overlap(i, &mdev->write_requests, sector, size) {
  1601. if (i == &peer_req->i)
  1602. continue;
  1603. if (!i->local) {
  1604. /*
  1605. * Our peer has sent a conflicting remote request; this
  1606. * should not happen in a two-node setup. Wait for the
  1607. * earlier peer request to complete.
  1608. */
  1609. err = drbd_wait_misc(mdev, i);
  1610. if (err)
  1611. goto out;
  1612. goto repeat;
  1613. }
  1614. equal = i->sector == sector && i->size == size;
  1615. if (resolve_conflicts) {
  1616. /*
  1617. * If the peer request is fully contained within the
  1618. * overlapping request, it can be discarded; otherwise,
  1619. * it will be retried once all overlapping requests
  1620. * have completed.
  1621. */
  1622. bool discard = i->sector <= sector && i->sector +
  1623. (i->size >> 9) >= sector + (size >> 9);
  1624. if (!equal)
  1625. dev_alert(DEV, "Concurrent writes detected: "
  1626. "local=%llus +%u, remote=%llus +%u, "
  1627. "assuming %s came first\n",
  1628. (unsigned long long)i->sector, i->size,
  1629. (unsigned long long)sector, size,
  1630. discard ? "local" : "remote");
  1631. inc_unacked(mdev);
  1632. peer_req->w.cb = discard ? e_send_discard_write :
  1633. e_send_retry_write;
  1634. list_add_tail(&peer_req->w.list, &mdev->done_ee);
  1635. wake_asender(mdev->tconn);
  1636. err = -ENOENT;
  1637. goto out;
  1638. } else {
  1639. struct drbd_request *req =
  1640. container_of(i, struct drbd_request, i);
  1641. if (!equal)
  1642. dev_alert(DEV, "Concurrent writes detected: "
  1643. "local=%llus +%u, remote=%llus +%u\n",
  1644. (unsigned long long)i->sector, i->size,
  1645. (unsigned long long)sector, size);
  1646. if (req->rq_state & RQ_LOCAL_PENDING ||
  1647. !(req->rq_state & RQ_POSTPONED)) {
  1648. /*
  1649. * Wait for the node with the discard flag to
  1650. * decide if this request will be discarded or
  1651. * retried. Requests that are discarded will
  1652. * disappear from the write_requests tree.
  1653. *
  1654. * In addition, wait for the conflicting
  1655. * request to finish locally before submitting
  1656. * the conflicting peer request.
  1657. */
  1658. err = drbd_wait_misc(mdev, &req->i);
  1659. if (err) {
  1660. _conn_request_state(mdev->tconn,
  1661. NS(conn, C_TIMEOUT),
  1662. CS_HARD);
  1663. fail_postponed_requests(mdev, sector, size);
  1664. goto out;
  1665. }
  1666. goto repeat;
  1667. }
  1668. /*
  1669. * Remember to restart the conflicting requests after
  1670. * the new peer request has completed.
  1671. */
  1672. peer_req->flags |= EE_RESTART_REQUESTS;
  1673. }
  1674. }
  1675. err = 0;
  1676. out:
  1677. if (err)
  1678. drbd_remove_epoch_entry_interval(mdev, peer_req);
  1679. return err;
  1680. }
  1681. /* mirrored write */
  1682. static int receive_Data(struct drbd_tconn *tconn, struct packet_info *pi)
  1683. {
  1684. struct drbd_conf *mdev;
  1685. sector_t sector;
  1686. struct drbd_peer_request *peer_req;
  1687. struct p_data *p = tconn->data.rbuf;
  1688. u32 peer_seq = be32_to_cpu(p->seq_num);
  1689. int rw = WRITE;
  1690. u32 dp_flags;
  1691. int err;
  1692. mdev = vnr_to_mdev(tconn, pi->vnr);
  1693. if (!mdev)
  1694. return -EIO;
  1695. if (!get_ldev(mdev)) {
  1696. int err2;
  1697. err = wait_for_and_update_peer_seq(mdev, peer_seq);
  1698. drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size);
  1699. atomic_inc(&mdev->current_epoch->epoch_size);
  1700. err2 = drbd_drain_block(mdev, pi->size);
  1701. if (!err)
  1702. err = err2;
  1703. return err;
  1704. }
  1705. /*
  1706. * Corresponding put_ldev done either below (on various errors), or in
  1707. * drbd_peer_request_endio, if we successfully submit the data at the
  1708. * end of this function.
  1709. */
  1710. sector = be64_to_cpu(p->sector);
  1711. peer_req = read_in_block(mdev, p->block_id, sector, pi->size);
  1712. if (!peer_req) {
  1713. put_ldev(mdev);
  1714. return -EIO;
  1715. }
  1716. peer_req->w.cb = e_end_block;
  1717. dp_flags = be32_to_cpu(p->dp_flags);
  1718. rw |= wire_flags_to_bio(mdev, dp_flags);
  1719. if (dp_flags & DP_MAY_SET_IN_SYNC)
  1720. peer_req->flags |= EE_MAY_SET_IN_SYNC;
  1721. spin_lock(&mdev->epoch_lock);
  1722. peer_req->epoch = mdev->current_epoch;
  1723. atomic_inc(&peer_req->epoch->epoch_size);
  1724. atomic_inc(&peer_req->epoch->active);
  1725. spin_unlock(&mdev->epoch_lock);
  1726. if (mdev->tconn->net_conf->two_primaries) {
  1727. err = wait_for_and_update_peer_seq(mdev, peer_seq);
  1728. if (err)
  1729. goto out_interrupted;
  1730. spin_lock_irq(&mdev->tconn->req_lock);
  1731. err = handle_write_conflicts(mdev, peer_req);
  1732. if (err) {
  1733. spin_unlock_irq(&mdev->tconn->req_lock);
  1734. if (err == -ENOENT) {
  1735. put_ldev(mdev);
  1736. return 0;
  1737. }
  1738. goto out_interrupted;
  1739. }
  1740. } else
  1741. spin_lock_irq(&mdev->tconn->req_lock);
  1742. list_add(&peer_req->w.list, &mdev->active_ee);
  1743. spin_unlock_irq(&mdev->tconn->req_lock);
  1744. switch (mdev->tconn->net_conf->wire_protocol) {
  1745. case DRBD_PROT_C:
  1746. inc_unacked(mdev);
  1747. /* corresponding dec_unacked() in e_end_block()
  1748. * respective _drbd_clear_done_ee */
  1749. break;
  1750. case DRBD_PROT_B:
  1751. /* I really don't like it that the receiver thread
  1752. * sends on the msock, but anyways */
  1753. drbd_send_ack(mdev, P_RECV_ACK, peer_req);
  1754. break;
  1755. case DRBD_PROT_A:
  1756. /* nothing to do */
  1757. break;
  1758. }
  1759. if (mdev->state.pdsk < D_INCONSISTENT) {
  1760. /* In case we have the only disk of the cluster, */
  1761. drbd_set_out_of_sync(mdev, peer_req->i.sector, peer_req->i.size);
  1762. peer_req->flags |= EE_CALL_AL_COMPLETE_IO;
  1763. peer_req->flags &= ~EE_MAY_SET_IN_SYNC;
  1764. drbd_al_begin_io(mdev, peer_req->i.sector);
  1765. }
  1766. err = drbd_submit_peer_request(mdev, peer_req, rw, DRBD_FAULT_DT_WR);
  1767. if (!err)
  1768. return 0;
  1769. /* don't care for the reason here */
  1770. dev_err(DEV, "submit failed, triggering re-connect\n");
  1771. spin_lock_irq(&mdev->tconn->req_lock);
  1772. list_del(&peer_req->w.list);
  1773. drbd_remove_epoch_entry_interval(mdev, peer_req);
  1774. spin_unlock_irq(&mdev->tconn->req_lock);
  1775. if (peer_req->flags & EE_CALL_AL_COMPLETE_IO)
  1776. drbd_al_complete_io(mdev, peer_req->i.sector);
  1777. out_interrupted:
  1778. drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + EV_CLEANUP);
  1779. put_ldev(mdev);
  1780. drbd_free_ee(mdev, peer_req);
  1781. return err;
  1782. }
  1783. /* We may throttle resync, if the lower device seems to be busy,
  1784. * and current sync rate is above c_min_rate.
  1785. *
  1786. * To decide whether or not the lower device is busy, we use a scheme similar
  1787. * to MD RAID is_mddev_idle(): if the partition stats reveal "significant"
  1788. * (more than 64 sectors) of activity we cannot account for with our own resync
  1789. * activity, it obviously is "busy".
  1790. *
  1791. * The current sync rate used here uses only the most recent two step marks,
  1792. * to have a short time average so we can react faster.
  1793. */
  1794. int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector)
  1795. {
  1796. struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk;
  1797. unsigned long db, dt, dbdt;
  1798. struct lc_element *tmp;
  1799. int curr_events;
  1800. int throttle = 0;
  1801. /* feature disabled? */
  1802. if (mdev->ldev->dc.c_min_rate == 0)
  1803. return 0;
  1804. spin_lock_irq(&mdev->al_lock);
  1805. tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector));
  1806. if (tmp) {
  1807. struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce);
  1808. if (test_bit(BME_PRIORITY, &bm_ext->flags)) {
  1809. spin_unlock_irq(&mdev->al_lock);
  1810. return 0;
  1811. }
  1812. /* Do not slow down if app IO is already waiting for this extent */
  1813. }
  1814. spin_unlock_irq(&mdev->al_lock);
  1815. curr_events = (int)part_stat_read(&disk->part0, sectors[0]) +
  1816. (int)part_stat_read(&disk->part0, sectors[1]) -
  1817. atomic_read(&mdev->rs_sect_ev);
  1818. if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) {
  1819. unsigned long rs_left;
  1820. int i;
  1821. mdev->rs_last_events = curr_events;
  1822. /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP,
  1823. * approx. */
  1824. i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS;
  1825. if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T)
  1826. rs_left = mdev->ov_left;
  1827. else
  1828. rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed;
  1829. dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ;
  1830. if (!dt)
  1831. dt++;
  1832. db = mdev->rs_mark_left[i] - rs_left;
  1833. dbdt = Bit2KB(db/dt);
  1834. if (dbdt > mdev->ldev->dc.c_min_rate)
  1835. throttle = 1;
  1836. }
  1837. return throttle;
  1838. }
  1839. static int receive_DataRequest(struct drbd_tconn *tconn, struct packet_info *pi)
  1840. {
  1841. struct drbd_conf *mdev;
  1842. sector_t sector;
  1843. sector_t capacity;
  1844. struct drbd_peer_request *peer_req;
  1845. struct digest_info *di = NULL;
  1846. int size, verb;
  1847. unsigned int fault_type;
  1848. struct p_block_req *p = tconn->data.rbuf;
  1849. mdev = vnr_to_mdev(tconn, pi->vnr);
  1850. if (!mdev)
  1851. return -EIO;
  1852. capacity = drbd_get_capacity(mdev->this_bdev);
  1853. sector = be64_to_cpu(p->sector);
  1854. size = be32_to_cpu(p->blksize);
  1855. if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) {
  1856. dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__,
  1857. (unsigned long long)sector, size);
  1858. return -EINVAL;
  1859. }
  1860. if (sector + (size>>9) > capacity) {
  1861. dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__,
  1862. (unsigned long long)sector, size);
  1863. return -EINVAL;
  1864. }
  1865. if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) {
  1866. verb = 1;
  1867. switch (pi->cmd) {
  1868. case P_DATA_REQUEST:
  1869. drbd_send_ack_rp(mdev, P_NEG_DREPLY, p);
  1870. break;
  1871. case P_RS_DATA_REQUEST:
  1872. case P_CSUM_RS_REQUEST:
  1873. case P_OV_REQUEST:
  1874. drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p);
  1875. break;
  1876. case P_OV_REPLY:
  1877. verb = 0;
  1878. dec_rs_pending(mdev);
  1879. drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC);
  1880. break;
  1881. default:
  1882. BUG();
  1883. }
  1884. if (verb && __ratelimit(&drbd_ratelimit_state))
  1885. dev_err(DEV, "Can not satisfy peer's read request, "
  1886. "no local data.\n");
  1887. /* drain possibly payload */
  1888. return drbd_drain_block(mdev, pi->size);
  1889. }
  1890. /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD
  1891. * "criss-cross" setup, that might cause write-out on some other DRBD,
  1892. * which in turn might block on the other node at this very place. */
  1893. peer_req = drbd_alloc_ee(mdev, p->block_id, sector, size, GFP_NOIO);
  1894. if (!peer_req) {
  1895. put_ldev(mdev);
  1896. return -ENOMEM;
  1897. }
  1898. switch (pi->cmd) {
  1899. case P_DATA_REQUEST:
  1900. peer_req->w.cb = w_e_end_data_req;
  1901. fault_type = DRBD_FAULT_DT_RD;
  1902. /* application IO, don't drbd_rs_begin_io */
  1903. goto submit;
  1904. case P_RS_DATA_REQUEST:
  1905. peer_req->w.cb = w_e_end_rsdata_req;
  1906. fault_type = DRBD_FAULT_RS_RD;
  1907. /* used in the sector offset progress display */
  1908. mdev->bm_resync_fo = BM_SECT_TO_BIT(sector);
  1909. break;
  1910. case P_OV_REPLY:
  1911. case P_CSUM_RS_REQUEST:
  1912. fault_type = DRBD_FAULT_RS_RD;
  1913. di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO);
  1914. if (!di)
  1915. goto out_free_e;
  1916. di->digest_size = pi->size;
  1917. di->digest = (((char *)di)+sizeof(struct digest_info));
  1918. peer_req->digest = di;
  1919. peer_req->flags |= EE_HAS_DIGEST;
  1920. if (drbd_recv_all(mdev->tconn, di->digest, pi->size))
  1921. goto out_free_e;
  1922. if (pi->cmd == P_CSUM_RS_REQUEST) {
  1923. D_ASSERT(mdev->tconn->agreed_pro_version >= 89);
  1924. peer_req->w.cb = w_e_end_csum_rs_req;
  1925. /* used in the sector offset progress display */
  1926. mdev->bm_resync_fo = BM_SECT_TO_BIT(sector);
  1927. } else if (pi->cmd == P_OV_REPLY) {
  1928. /* track progress, we may need to throttle */
  1929. atomic_add(size >> 9, &mdev->rs_sect_in);
  1930. peer_req->w.cb = w_e_end_ov_reply;
  1931. dec_rs_pending(mdev);
  1932. /* drbd_rs_begin_io done when we sent this request,
  1933. * but accounting still needs to be done. */
  1934. goto submit_for_resync;
  1935. }
  1936. break;
  1937. case P_OV_REQUEST:
  1938. if (mdev->ov_start_sector == ~(sector_t)0 &&
  1939. mdev->tconn->agreed_pro_version >= 90) {
  1940. unsigned long now = jiffies;
  1941. int i;
  1942. mdev->ov_start_sector = sector;
  1943. mdev->ov_position = sector;
  1944. mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector);
  1945. mdev->rs_total = mdev->ov_left;
  1946. for (i = 0; i < DRBD_SYNC_MARKS; i++) {
  1947. mdev->rs_mark_left[i] = mdev->ov_left;
  1948. mdev->rs_mark_time[i] = now;
  1949. }
  1950. dev_info(DEV, "Online Verify start sector: %llu\n",
  1951. (unsigned long long)sector);
  1952. }
  1953. peer_req->w.cb = w_e_end_ov_req;
  1954. fault_type = DRBD_FAULT_RS_RD;
  1955. break;
  1956. default:
  1957. BUG();
  1958. }
  1959. /* Throttle, drbd_rs_begin_io and submit should become asynchronous
  1960. * wrt the receiver, but it is not as straightforward as it may seem.
  1961. * Various places in the resync start and stop logic assume resync
  1962. * requests are processed in order, requeuing this on the worker thread
  1963. * introduces a bunch of new code for synchronization between threads.
  1964. *
  1965. * Unlimited throttling before drbd_rs_begin_io may stall the resync
  1966. * "forever", throttling after drbd_rs_begin_io will lock that extent
  1967. * for application writes for the same time. For now, just throttle
  1968. * here, where the rest of the code expects the receiver to sleep for
  1969. * a while, anyways.
  1970. */
  1971. /* Throttle before drbd_rs_begin_io, as that locks out application IO;
  1972. * this defers syncer requests for some time, before letting at least
  1973. * on request through. The resync controller on the receiving side
  1974. * will adapt to the incoming rate accordingly.
  1975. *
  1976. * We cannot throttle here if remote is Primary/SyncTarget:
  1977. * we would also throttle its application reads.
  1978. * In that case, throttling is done on the SyncTarget only.
  1979. */
  1980. if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector))
  1981. schedule_timeout_uninterruptible(HZ/10);
  1982. if (drbd_rs_begin_io(mdev, sector))
  1983. goto out_free_e;
  1984. submit_for_resync:
  1985. atomic_add(size >> 9, &mdev->rs_sect_ev);
  1986. submit:
  1987. inc_unacked(mdev);
  1988. spin_lock_irq(&mdev->tconn->req_lock);
  1989. list_add_tail(&peer_req->w.list, &mdev->read_ee);
  1990. spin_unlock_irq(&mdev->tconn->req_lock);
  1991. if (drbd_submit_peer_request(mdev, peer_req, READ, fault_type) == 0)
  1992. return 0;
  1993. /* don't care for the reason here */
  1994. dev_err(DEV, "submit failed, triggering re-connect\n");
  1995. spin_lock_irq(&mdev->tconn->req_lock);
  1996. list_del(&peer_req->w.list);
  1997. spin_unlock_irq(&mdev->tconn->req_lock);
  1998. /* no drbd_rs_complete_io(), we are dropping the connection anyways */
  1999. out_free_e:
  2000. put_ldev(mdev);
  2001. drbd_free_ee(mdev, peer_req);
  2002. return -EIO;
  2003. }
  2004. static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local)
  2005. {
  2006. int self, peer, rv = -100;
  2007. unsigned long ch_self, ch_peer;
  2008. self = mdev->ldev->md.uuid[UI_BITMAP] & 1;
  2009. peer = mdev->p_uuid[UI_BITMAP] & 1;
  2010. ch_peer = mdev->p_uuid[UI_SIZE];
  2011. ch_self = mdev->comm_bm_set;
  2012. switch (mdev->tconn->net_conf->after_sb_0p) {
  2013. case ASB_CONSENSUS:
  2014. case ASB_DISCARD_SECONDARY:
  2015. case ASB_CALL_HELPER:
  2016. dev_err(DEV, "Configuration error.\n");
  2017. break;
  2018. case ASB_DISCONNECT:
  2019. break;
  2020. case ASB_DISCARD_YOUNGER_PRI:
  2021. if (self == 0 && peer == 1) {
  2022. rv = -1;
  2023. break;
  2024. }
  2025. if (self == 1 && peer == 0) {
  2026. rv = 1;
  2027. break;
  2028. }
  2029. /* Else fall through to one of the other strategies... */
  2030. case ASB_DISCARD_OLDER_PRI:
  2031. if (self == 0 && peer == 1) {
  2032. rv = 1;
  2033. break;
  2034. }
  2035. if (self == 1 && peer == 0) {
  2036. rv = -1;
  2037. break;
  2038. }
  2039. /* Else fall through to one of the other strategies... */
  2040. dev_warn(DEV, "Discard younger/older primary did not find a decision\n"
  2041. "Using discard-least-changes instead\n");
  2042. case ASB_DISCARD_ZERO_CHG:
  2043. if (ch_peer == 0 && ch_self == 0) {
  2044. rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags)
  2045. ? -1 : 1;
  2046. break;
  2047. } else {
  2048. if (ch_peer == 0) { rv = 1; break; }
  2049. if (ch_self == 0) { rv = -1; break; }
  2050. }
  2051. if (mdev->tconn->net_conf->after_sb_0p == ASB_DISCARD_ZERO_CHG)
  2052. break;
  2053. case ASB_DISCARD_LEAST_CHG:
  2054. if (ch_self < ch_peer)
  2055. rv = -1;
  2056. else if (ch_self > ch_peer)
  2057. rv = 1;
  2058. else /* ( ch_self == ch_peer ) */
  2059. /* Well, then use something else. */
  2060. rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags)
  2061. ? -1 : 1;
  2062. break;
  2063. case ASB_DISCARD_LOCAL:
  2064. rv = -1;
  2065. break;
  2066. case ASB_DISCARD_REMOTE:
  2067. rv = 1;
  2068. }
  2069. return rv;
  2070. }
  2071. static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local)
  2072. {
  2073. int hg, rv = -100;
  2074. switch (mdev->tconn->net_conf->after_sb_1p) {
  2075. case ASB_DISCARD_YOUNGER_PRI:
  2076. case ASB_DISCARD_OLDER_PRI:
  2077. case ASB_DISCARD_LEAST_CHG:
  2078. case ASB_DISCARD_LOCAL:
  2079. case ASB_DISCARD_REMOTE:
  2080. dev_err(DEV, "Configuration error.\n");
  2081. break;
  2082. case ASB_DISCONNECT:
  2083. break;
  2084. case ASB_CONSENSUS:
  2085. hg = drbd_asb_recover_0p(mdev);
  2086. if (hg == -1 && mdev->state.role == R_SECONDARY)
  2087. rv = hg;
  2088. if (hg == 1 && mdev->state.role == R_PRIMARY)
  2089. rv = hg;
  2090. break;
  2091. case ASB_VIOLENTLY:
  2092. rv = drbd_asb_recover_0p(mdev);
  2093. break;
  2094. case ASB_DISCARD_SECONDARY:
  2095. return mdev->state.role == R_PRIMARY ? 1 : -1;
  2096. case ASB_CALL_HELPER:
  2097. hg = drbd_asb_recover_0p(mdev);
  2098. if (hg == -1 && mdev->state.role == R_PRIMARY) {
  2099. enum drbd_state_rv rv2;
  2100. drbd_set_role(mdev, R_SECONDARY, 0);
  2101. /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE,
  2102. * we might be here in C_WF_REPORT_PARAMS which is transient.
  2103. * we do not need to wait for the after state change work either. */
  2104. rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY));
  2105. if (rv2 != SS_SUCCESS) {
  2106. drbd_khelper(mdev, "pri-lost-after-sb");
  2107. } else {
  2108. dev_warn(DEV, "Successfully gave up primary role.\n");
  2109. rv = hg;
  2110. }
  2111. } else
  2112. rv = hg;
  2113. }
  2114. return rv;
  2115. }
  2116. static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local)
  2117. {
  2118. int hg, rv = -100;
  2119. switch (mdev->tconn->net_conf->after_sb_2p) {
  2120. case ASB_DISCARD_YOUNGER_PRI:
  2121. case ASB_DISCARD_OLDER_PRI:
  2122. case ASB_DISCARD_LEAST_CHG:
  2123. case ASB_DISCARD_LOCAL:
  2124. case ASB_DISCARD_REMOTE:
  2125. case ASB_CONSENSUS:
  2126. case ASB_DISCARD_SECONDARY:
  2127. dev_err(DEV, "Configuration error.\n");
  2128. break;
  2129. case ASB_VIOLENTLY:
  2130. rv = drbd_asb_recover_0p(mdev);
  2131. break;
  2132. case ASB_DISCONNECT:
  2133. break;
  2134. case ASB_CALL_HELPER:
  2135. hg = drbd_asb_recover_0p(mdev);
  2136. if (hg == -1) {
  2137. enum drbd_state_rv rv2;
  2138. /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE,
  2139. * we might be here in C_WF_REPORT_PARAMS which is transient.
  2140. * we do not need to wait for the after state change work either. */
  2141. rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY));
  2142. if (rv2 != SS_SUCCESS) {
  2143. drbd_khelper(mdev, "pri-lost-after-sb");
  2144. } else {
  2145. dev_warn(DEV, "Successfully gave up primary role.\n");
  2146. rv = hg;
  2147. }
  2148. } else
  2149. rv = hg;
  2150. }
  2151. return rv;
  2152. }
  2153. static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid,
  2154. u64 bits, u64 flags)
  2155. {
  2156. if (!uuid) {
  2157. dev_info(DEV, "%s uuid info vanished while I was looking!\n", text);
  2158. return;
  2159. }
  2160. dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n",
  2161. text,
  2162. (unsigned long long)uuid[UI_CURRENT],
  2163. (unsigned long long)uuid[UI_BITMAP],
  2164. (unsigned long long)uuid[UI_HISTORY_START],
  2165. (unsigned long long)uuid[UI_HISTORY_END],
  2166. (unsigned long long)bits,
  2167. (unsigned long long)flags);
  2168. }
  2169. /*
  2170. 100 after split brain try auto recover
  2171. 2 C_SYNC_SOURCE set BitMap
  2172. 1 C_SYNC_SOURCE use BitMap
  2173. 0 no Sync
  2174. -1 C_SYNC_TARGET use BitMap
  2175. -2 C_SYNC_TARGET set BitMap
  2176. -100 after split brain, disconnect
  2177. -1000 unrelated data
  2178. -1091 requires proto 91
  2179. -1096 requires proto 96
  2180. */
  2181. static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local)
  2182. {
  2183. u64 self, peer;
  2184. int i, j;
  2185. self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1);
  2186. peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1);
  2187. *rule_nr = 10;
  2188. if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED)
  2189. return 0;
  2190. *rule_nr = 20;
  2191. if ((self == UUID_JUST_CREATED || self == (u64)0) &&
  2192. peer != UUID_JUST_CREATED)
  2193. return -2;
  2194. *rule_nr = 30;
  2195. if (self != UUID_JUST_CREATED &&
  2196. (peer == UUID_JUST_CREATED || peer == (u64)0))
  2197. return 2;
  2198. if (self == peer) {
  2199. int rct, dc; /* roles at crash time */
  2200. if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) {
  2201. if (mdev->tconn->agreed_pro_version < 91)
  2202. return -1091;
  2203. if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) &&
  2204. (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) {
  2205. dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n");
  2206. drbd_uuid_set_bm(mdev, 0UL);
  2207. drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid,
  2208. mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0);
  2209. *rule_nr = 34;
  2210. } else {
  2211. dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n");
  2212. *rule_nr = 36;
  2213. }
  2214. return 1;
  2215. }
  2216. if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) {
  2217. if (mdev->tconn->agreed_pro_version < 91)
  2218. return -1091;
  2219. if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) &&
  2220. (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) {
  2221. dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n");
  2222. mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START];
  2223. mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP];
  2224. mdev->p_uuid[UI_BITMAP] = 0UL;
  2225. drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]);
  2226. *rule_nr = 35;
  2227. } else {
  2228. dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n");
  2229. *rule_nr = 37;
  2230. }
  2231. return -1;
  2232. }
  2233. /* Common power [off|failure] */
  2234. rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) +
  2235. (mdev->p_uuid[UI_FLAGS] & 2);
  2236. /* lowest bit is set when we were primary,
  2237. * next bit (weight 2) is set when peer was primary */
  2238. *rule_nr = 40;
  2239. switch (rct) {
  2240. case 0: /* !self_pri && !peer_pri */ return 0;
  2241. case 1: /* self_pri && !peer_pri */ return 1;
  2242. case 2: /* !self_pri && peer_pri */ return -1;
  2243. case 3: /* self_pri && peer_pri */
  2244. dc = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags);
  2245. return dc ? -1 : 1;
  2246. }
  2247. }
  2248. *rule_nr = 50;
  2249. peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1);
  2250. if (self == peer)
  2251. return -1;
  2252. *rule_nr = 51;
  2253. peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1);
  2254. if (self == peer) {
  2255. if (mdev->tconn->agreed_pro_version < 96 ?
  2256. (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) ==
  2257. (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) :
  2258. peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) {
  2259. /* The last P_SYNC_UUID did not get though. Undo the last start of
  2260. resync as sync source modifications of the peer's UUIDs. */
  2261. if (mdev->tconn->agreed_pro_version < 91)
  2262. return -1091;
  2263. mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START];
  2264. mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1];
  2265. dev_info(DEV, "Did not got last syncUUID packet, corrected:\n");
  2266. drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]);
  2267. return -1;
  2268. }
  2269. }
  2270. *rule_nr = 60;
  2271. self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1);
  2272. for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) {
  2273. peer = mdev->p_uuid[i] & ~((u64)1);
  2274. if (self == peer)
  2275. return -2;
  2276. }
  2277. *rule_nr = 70;
  2278. self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1);
  2279. peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1);
  2280. if (self == peer)
  2281. return 1;
  2282. *rule_nr = 71;
  2283. self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1);
  2284. if (self == peer) {
  2285. if (mdev->tconn->agreed_pro_version < 96 ?
  2286. (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) ==
  2287. (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) :
  2288. self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) {
  2289. /* The last P_SYNC_UUID did not get though. Undo the last start of
  2290. resync as sync source modifications of our UUIDs. */
  2291. if (mdev->tconn->agreed_pro_version < 91)
  2292. return -1091;
  2293. _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]);
  2294. _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]);
  2295. dev_info(DEV, "Last syncUUID did not get through, corrected:\n");
  2296. drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid,
  2297. mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0);
  2298. return 1;
  2299. }
  2300. }
  2301. *rule_nr = 80;
  2302. peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1);
  2303. for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) {
  2304. self = mdev->ldev->md.uuid[i] & ~((u64)1);
  2305. if (self == peer)
  2306. return 2;
  2307. }
  2308. *rule_nr = 90;
  2309. self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1);
  2310. peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1);
  2311. if (self == peer && self != ((u64)0))
  2312. return 100;
  2313. *rule_nr = 100;
  2314. for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) {
  2315. self = mdev->ldev->md.uuid[i] & ~((u64)1);
  2316. for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) {
  2317. peer = mdev->p_uuid[j] & ~((u64)1);
  2318. if (self == peer)
  2319. return -100;
  2320. }
  2321. }
  2322. return -1000;
  2323. }
  2324. /* drbd_sync_handshake() returns the new conn state on success, or
  2325. CONN_MASK (-1) on failure.
  2326. */
  2327. static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role,
  2328. enum drbd_disk_state peer_disk) __must_hold(local)
  2329. {
  2330. int hg, rule_nr;
  2331. enum drbd_conns rv = C_MASK;
  2332. enum drbd_disk_state mydisk;
  2333. mydisk = mdev->state.disk;
  2334. if (mydisk == D_NEGOTIATING)
  2335. mydisk = mdev->new_state_tmp.disk;
  2336. dev_info(DEV, "drbd_sync_handshake:\n");
  2337. drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0);
  2338. drbd_uuid_dump(mdev, "peer", mdev->p_uuid,
  2339. mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]);
  2340. hg = drbd_uuid_compare(mdev, &rule_nr);
  2341. dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr);
  2342. if (hg == -1000) {
  2343. dev_alert(DEV, "Unrelated data, aborting!\n");
  2344. return C_MASK;
  2345. }
  2346. if (hg < -1000) {
  2347. dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000);
  2348. return C_MASK;
  2349. }
  2350. if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) ||
  2351. (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) {
  2352. int f = (hg == -100) || abs(hg) == 2;
  2353. hg = mydisk > D_INCONSISTENT ? 1 : -1;
  2354. if (f)
  2355. hg = hg*2;
  2356. dev_info(DEV, "Becoming sync %s due to disk states.\n",
  2357. hg > 0 ? "source" : "target");
  2358. }
  2359. if (abs(hg) == 100)
  2360. drbd_khelper(mdev, "initial-split-brain");
  2361. if (hg == 100 || (hg == -100 && mdev->tconn->net_conf->always_asbp)) {
  2362. int pcount = (mdev->state.role == R_PRIMARY)
  2363. + (peer_role == R_PRIMARY);
  2364. int forced = (hg == -100);
  2365. switch (pcount) {
  2366. case 0:
  2367. hg = drbd_asb_recover_0p(mdev);
  2368. break;
  2369. case 1:
  2370. hg = drbd_asb_recover_1p(mdev);
  2371. break;
  2372. case 2:
  2373. hg = drbd_asb_recover_2p(mdev);
  2374. break;
  2375. }
  2376. if (abs(hg) < 100) {
  2377. dev_warn(DEV, "Split-Brain detected, %d primaries, "
  2378. "automatically solved. Sync from %s node\n",
  2379. pcount, (hg < 0) ? "peer" : "this");
  2380. if (forced) {
  2381. dev_warn(DEV, "Doing a full sync, since"
  2382. " UUIDs where ambiguous.\n");
  2383. hg = hg*2;
  2384. }
  2385. }
  2386. }
  2387. if (hg == -100) {
  2388. if (mdev->tconn->net_conf->want_lose && !(mdev->p_uuid[UI_FLAGS]&1))
  2389. hg = -1;
  2390. if (!mdev->tconn->net_conf->want_lose && (mdev->p_uuid[UI_FLAGS]&1))
  2391. hg = 1;
  2392. if (abs(hg) < 100)
  2393. dev_warn(DEV, "Split-Brain detected, manually solved. "
  2394. "Sync from %s node\n",
  2395. (hg < 0) ? "peer" : "this");
  2396. }
  2397. if (hg == -100) {
  2398. /* FIXME this log message is not correct if we end up here
  2399. * after an attempted attach on a diskless node.
  2400. * We just refuse to attach -- well, we drop the "connection"
  2401. * to that disk, in a way... */
  2402. dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n");
  2403. drbd_khelper(mdev, "split-brain");
  2404. return C_MASK;
  2405. }
  2406. if (hg > 0 && mydisk <= D_INCONSISTENT) {
  2407. dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n");
  2408. return C_MASK;
  2409. }
  2410. if (hg < 0 && /* by intention we do not use mydisk here. */
  2411. mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) {
  2412. switch (mdev->tconn->net_conf->rr_conflict) {
  2413. case ASB_CALL_HELPER:
  2414. drbd_khelper(mdev, "pri-lost");
  2415. /* fall through */
  2416. case ASB_DISCONNECT:
  2417. dev_err(DEV, "I shall become SyncTarget, but I am primary!\n");
  2418. return C_MASK;
  2419. case ASB_VIOLENTLY:
  2420. dev_warn(DEV, "Becoming SyncTarget, violating the stable-data"
  2421. "assumption\n");
  2422. }
  2423. }
  2424. if (mdev->tconn->net_conf->dry_run || test_bit(CONN_DRY_RUN, &mdev->tconn->flags)) {
  2425. if (hg == 0)
  2426. dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n");
  2427. else
  2428. dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.",
  2429. drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET),
  2430. abs(hg) >= 2 ? "full" : "bit-map based");
  2431. return C_MASK;
  2432. }
  2433. if (abs(hg) >= 2) {
  2434. dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n");
  2435. if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake",
  2436. BM_LOCKED_SET_ALLOWED))
  2437. return C_MASK;
  2438. }
  2439. if (hg > 0) { /* become sync source. */
  2440. rv = C_WF_BITMAP_S;
  2441. } else if (hg < 0) { /* become sync target */
  2442. rv = C_WF_BITMAP_T;
  2443. } else {
  2444. rv = C_CONNECTED;
  2445. if (drbd_bm_total_weight(mdev)) {
  2446. dev_info(DEV, "No resync, but %lu bits in bitmap!\n",
  2447. drbd_bm_total_weight(mdev));
  2448. }
  2449. }
  2450. return rv;
  2451. }
  2452. /* returns 1 if invalid */
  2453. static int cmp_after_sb(enum drbd_after_sb_p peer, enum drbd_after_sb_p self)
  2454. {
  2455. /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */
  2456. if ((peer == ASB_DISCARD_REMOTE && self == ASB_DISCARD_LOCAL) ||
  2457. (self == ASB_DISCARD_REMOTE && peer == ASB_DISCARD_LOCAL))
  2458. return 0;
  2459. /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */
  2460. if (peer == ASB_DISCARD_REMOTE || peer == ASB_DISCARD_LOCAL ||
  2461. self == ASB_DISCARD_REMOTE || self == ASB_DISCARD_LOCAL)
  2462. return 1;
  2463. /* everything else is valid if they are equal on both sides. */
  2464. if (peer == self)
  2465. return 0;
  2466. /* everything es is invalid. */
  2467. return 1;
  2468. }
  2469. static int receive_protocol(struct drbd_tconn *tconn, struct packet_info *pi)
  2470. {
  2471. struct p_protocol *p = tconn->data.rbuf;
  2472. int p_proto, p_after_sb_0p, p_after_sb_1p, p_after_sb_2p;
  2473. int p_want_lose, p_two_primaries, cf;
  2474. char p_integrity_alg[SHARED_SECRET_MAX] = "";
  2475. p_proto = be32_to_cpu(p->protocol);
  2476. p_after_sb_0p = be32_to_cpu(p->after_sb_0p);
  2477. p_after_sb_1p = be32_to_cpu(p->after_sb_1p);
  2478. p_after_sb_2p = be32_to_cpu(p->after_sb_2p);
  2479. p_two_primaries = be32_to_cpu(p->two_primaries);
  2480. cf = be32_to_cpu(p->conn_flags);
  2481. p_want_lose = cf & CF_WANT_LOSE;
  2482. clear_bit(CONN_DRY_RUN, &tconn->flags);
  2483. if (cf & CF_DRY_RUN)
  2484. set_bit(CONN_DRY_RUN, &tconn->flags);
  2485. if (p_proto != tconn->net_conf->wire_protocol) {
  2486. conn_err(tconn, "incompatible communication protocols\n");
  2487. goto disconnect;
  2488. }
  2489. if (cmp_after_sb(p_after_sb_0p, tconn->net_conf->after_sb_0p)) {
  2490. conn_err(tconn, "incompatible after-sb-0pri settings\n");
  2491. goto disconnect;
  2492. }
  2493. if (cmp_after_sb(p_after_sb_1p, tconn->net_conf->after_sb_1p)) {
  2494. conn_err(tconn, "incompatible after-sb-1pri settings\n");
  2495. goto disconnect;
  2496. }
  2497. if (cmp_after_sb(p_after_sb_2p, tconn->net_conf->after_sb_2p)) {
  2498. conn_err(tconn, "incompatible after-sb-2pri settings\n");
  2499. goto disconnect;
  2500. }
  2501. if (p_want_lose && tconn->net_conf->want_lose) {
  2502. conn_err(tconn, "both sides have the 'want_lose' flag set\n");
  2503. goto disconnect;
  2504. }
  2505. if (p_two_primaries != tconn->net_conf->two_primaries) {
  2506. conn_err(tconn, "incompatible setting of the two-primaries options\n");
  2507. goto disconnect;
  2508. }
  2509. if (tconn->agreed_pro_version >= 87) {
  2510. unsigned char *my_alg = tconn->net_conf->integrity_alg;
  2511. int err;
  2512. err = drbd_recv_all(tconn, p_integrity_alg, pi->size);
  2513. if (err)
  2514. return err;
  2515. p_integrity_alg[SHARED_SECRET_MAX-1] = 0;
  2516. if (strcmp(p_integrity_alg, my_alg)) {
  2517. conn_err(tconn, "incompatible setting of the data-integrity-alg\n");
  2518. goto disconnect;
  2519. }
  2520. conn_info(tconn, "data-integrity-alg: %s\n",
  2521. my_alg[0] ? my_alg : (unsigned char *)"<not-used>");
  2522. }
  2523. return 0;
  2524. disconnect:
  2525. conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD);
  2526. return -EIO;
  2527. }
  2528. /* helper function
  2529. * input: alg name, feature name
  2530. * return: NULL (alg name was "")
  2531. * ERR_PTR(error) if something goes wrong
  2532. * or the crypto hash ptr, if it worked out ok. */
  2533. struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev,
  2534. const char *alg, const char *name)
  2535. {
  2536. struct crypto_hash *tfm;
  2537. if (!alg[0])
  2538. return NULL;
  2539. tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC);
  2540. if (IS_ERR(tfm)) {
  2541. dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n",
  2542. alg, name, PTR_ERR(tfm));
  2543. return tfm;
  2544. }
  2545. if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) {
  2546. crypto_free_hash(tfm);
  2547. dev_err(DEV, "\"%s\" is not a digest (%s)\n", alg, name);
  2548. return ERR_PTR(-EINVAL);
  2549. }
  2550. return tfm;
  2551. }
  2552. static int ignore_remaining_packet(struct drbd_tconn *tconn, struct packet_info *pi)
  2553. {
  2554. void *buffer = tconn->data.rbuf;
  2555. int size = pi->size;
  2556. while (size) {
  2557. int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE);
  2558. s = drbd_recv(tconn, buffer, s);
  2559. if (s <= 0) {
  2560. if (s < 0)
  2561. return s;
  2562. break;
  2563. }
  2564. size -= s;
  2565. }
  2566. if (size)
  2567. return -EIO;
  2568. return 0;
  2569. }
  2570. /*
  2571. * config_unknown_volume - device configuration command for unknown volume
  2572. *
  2573. * When a device is added to an existing connection, the node on which the
  2574. * device is added first will send configuration commands to its peer but the
  2575. * peer will not know about the device yet. It will warn and ignore these
  2576. * commands. Once the device is added on the second node, the second node will
  2577. * send the same device configuration commands, but in the other direction.
  2578. *
  2579. * (We can also end up here if drbd is misconfigured.)
  2580. */
  2581. static int config_unknown_volume(struct drbd_tconn *tconn, struct packet_info *pi)
  2582. {
  2583. conn_warn(tconn, "Volume %u unknown; ignoring %s packet\n",
  2584. pi->vnr, cmdname(pi->cmd));
  2585. return ignore_remaining_packet(tconn, pi);
  2586. }
  2587. static int receive_SyncParam(struct drbd_tconn *tconn, struct packet_info *pi)
  2588. {
  2589. struct drbd_conf *mdev;
  2590. struct p_rs_param_95 *p = tconn->data.rbuf;
  2591. unsigned int header_size, data_size, exp_max_sz;
  2592. struct crypto_hash *verify_tfm = NULL;
  2593. struct crypto_hash *csums_tfm = NULL;
  2594. const int apv = tconn->agreed_pro_version;
  2595. int *rs_plan_s = NULL;
  2596. int fifo_size = 0;
  2597. int err;
  2598. mdev = vnr_to_mdev(tconn, pi->vnr);
  2599. if (!mdev)
  2600. return config_unknown_volume(tconn, pi);
  2601. exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param)
  2602. : apv == 88 ? sizeof(struct p_rs_param)
  2603. + SHARED_SECRET_MAX
  2604. : apv <= 94 ? sizeof(struct p_rs_param_89)
  2605. : /* apv >= 95 */ sizeof(struct p_rs_param_95);
  2606. if (pi->size > exp_max_sz) {
  2607. dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n",
  2608. pi->size, exp_max_sz);
  2609. return -EIO;
  2610. }
  2611. if (apv <= 88) {
  2612. header_size = sizeof(struct p_rs_param) - sizeof(struct p_header);
  2613. data_size = pi->size - header_size;
  2614. } else if (apv <= 94) {
  2615. header_size = sizeof(struct p_rs_param_89) - sizeof(struct p_header);
  2616. data_size = pi->size - header_size;
  2617. D_ASSERT(data_size == 0);
  2618. } else {
  2619. header_size = sizeof(struct p_rs_param_95) - sizeof(struct p_header);
  2620. data_size = pi->size - header_size;
  2621. D_ASSERT(data_size == 0);
  2622. }
  2623. /* initialize verify_alg and csums_alg */
  2624. memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX);
  2625. err = drbd_recv_all(mdev->tconn, &p->head.payload, header_size);
  2626. if (err)
  2627. return err;
  2628. if (get_ldev(mdev)) {
  2629. mdev->ldev->dc.resync_rate = be32_to_cpu(p->rate);
  2630. put_ldev(mdev);
  2631. }
  2632. if (apv >= 88) {
  2633. if (apv == 88) {
  2634. if (data_size > SHARED_SECRET_MAX) {
  2635. dev_err(DEV, "verify-alg too long, "
  2636. "peer wants %u, accepting only %u byte\n",
  2637. data_size, SHARED_SECRET_MAX);
  2638. return -EIO;
  2639. }
  2640. err = drbd_recv_all(mdev->tconn, p->verify_alg, data_size);
  2641. if (err)
  2642. return err;
  2643. /* we expect NUL terminated string */
  2644. /* but just in case someone tries to be evil */
  2645. D_ASSERT(p->verify_alg[data_size-1] == 0);
  2646. p->verify_alg[data_size-1] = 0;
  2647. } else /* apv >= 89 */ {
  2648. /* we still expect NUL terminated strings */
  2649. /* but just in case someone tries to be evil */
  2650. D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0);
  2651. D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0);
  2652. p->verify_alg[SHARED_SECRET_MAX-1] = 0;
  2653. p->csums_alg[SHARED_SECRET_MAX-1] = 0;
  2654. }
  2655. if (strcmp(mdev->tconn->net_conf->verify_alg, p->verify_alg)) {
  2656. if (mdev->state.conn == C_WF_REPORT_PARAMS) {
  2657. dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n",
  2658. mdev->tconn->net_conf->verify_alg, p->verify_alg);
  2659. goto disconnect;
  2660. }
  2661. verify_tfm = drbd_crypto_alloc_digest_safe(mdev,
  2662. p->verify_alg, "verify-alg");
  2663. if (IS_ERR(verify_tfm)) {
  2664. verify_tfm = NULL;
  2665. goto disconnect;
  2666. }
  2667. }
  2668. if (apv >= 89 && strcmp(mdev->tconn->net_conf->csums_alg, p->csums_alg)) {
  2669. if (mdev->state.conn == C_WF_REPORT_PARAMS) {
  2670. dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n",
  2671. mdev->tconn->net_conf->csums_alg, p->csums_alg);
  2672. goto disconnect;
  2673. }
  2674. csums_tfm = drbd_crypto_alloc_digest_safe(mdev,
  2675. p->csums_alg, "csums-alg");
  2676. if (IS_ERR(csums_tfm)) {
  2677. csums_tfm = NULL;
  2678. goto disconnect;
  2679. }
  2680. }
  2681. if (apv > 94 && get_ldev(mdev)) {
  2682. mdev->ldev->dc.resync_rate = be32_to_cpu(p->rate);
  2683. mdev->ldev->dc.c_plan_ahead = be32_to_cpu(p->c_plan_ahead);
  2684. mdev->ldev->dc.c_delay_target = be32_to_cpu(p->c_delay_target);
  2685. mdev->ldev->dc.c_fill_target = be32_to_cpu(p->c_fill_target);
  2686. mdev->ldev->dc.c_max_rate = be32_to_cpu(p->c_max_rate);
  2687. fifo_size = (mdev->ldev->dc.c_plan_ahead * 10 * SLEEP_TIME) / HZ;
  2688. if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) {
  2689. rs_plan_s = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL);
  2690. if (!rs_plan_s) {
  2691. dev_err(DEV, "kmalloc of fifo_buffer failed");
  2692. put_ldev(mdev);
  2693. goto disconnect;
  2694. }
  2695. }
  2696. put_ldev(mdev);
  2697. }
  2698. spin_lock(&mdev->peer_seq_lock);
  2699. /* lock against drbd_nl_syncer_conf() */
  2700. if (verify_tfm) {
  2701. strcpy(mdev->tconn->net_conf->verify_alg, p->verify_alg);
  2702. mdev->tconn->net_conf->verify_alg_len = strlen(p->verify_alg) + 1;
  2703. crypto_free_hash(mdev->tconn->verify_tfm);
  2704. mdev->tconn->verify_tfm = verify_tfm;
  2705. dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg);
  2706. }
  2707. if (csums_tfm) {
  2708. strcpy(mdev->tconn->net_conf->csums_alg, p->csums_alg);
  2709. mdev->tconn->net_conf->csums_alg_len = strlen(p->csums_alg) + 1;
  2710. crypto_free_hash(mdev->tconn->csums_tfm);
  2711. mdev->tconn->csums_tfm = csums_tfm;
  2712. dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg);
  2713. }
  2714. if (fifo_size != mdev->rs_plan_s.size) {
  2715. kfree(mdev->rs_plan_s.values);
  2716. mdev->rs_plan_s.values = rs_plan_s;
  2717. mdev->rs_plan_s.size = fifo_size;
  2718. mdev->rs_planed = 0;
  2719. }
  2720. spin_unlock(&mdev->peer_seq_lock);
  2721. }
  2722. return 0;
  2723. disconnect:
  2724. /* just for completeness: actually not needed,
  2725. * as this is not reached if csums_tfm was ok. */
  2726. crypto_free_hash(csums_tfm);
  2727. /* but free the verify_tfm again, if csums_tfm did not work out */
  2728. crypto_free_hash(verify_tfm);
  2729. conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD);
  2730. return -EIO;
  2731. }
  2732. /* warn if the arguments differ by more than 12.5% */
  2733. static void warn_if_differ_considerably(struct drbd_conf *mdev,
  2734. const char *s, sector_t a, sector_t b)
  2735. {
  2736. sector_t d;
  2737. if (a == 0 || b == 0)
  2738. return;
  2739. d = (a > b) ? (a - b) : (b - a);
  2740. if (d > (a>>3) || d > (b>>3))
  2741. dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s,
  2742. (unsigned long long)a, (unsigned long long)b);
  2743. }
  2744. static int receive_sizes(struct drbd_tconn *tconn, struct packet_info *pi)
  2745. {
  2746. struct drbd_conf *mdev;
  2747. struct p_sizes *p = tconn->data.rbuf;
  2748. enum determine_dev_size dd = unchanged;
  2749. sector_t p_size, p_usize, my_usize;
  2750. int ldsc = 0; /* local disk size changed */
  2751. enum dds_flags ddsf;
  2752. mdev = vnr_to_mdev(tconn, pi->vnr);
  2753. if (!mdev)
  2754. return config_unknown_volume(tconn, pi);
  2755. p_size = be64_to_cpu(p->d_size);
  2756. p_usize = be64_to_cpu(p->u_size);
  2757. /* just store the peer's disk size for now.
  2758. * we still need to figure out whether we accept that. */
  2759. mdev->p_size = p_size;
  2760. if (get_ldev(mdev)) {
  2761. warn_if_differ_considerably(mdev, "lower level device sizes",
  2762. p_size, drbd_get_max_capacity(mdev->ldev));
  2763. warn_if_differ_considerably(mdev, "user requested size",
  2764. p_usize, mdev->ldev->dc.disk_size);
  2765. /* if this is the first connect, or an otherwise expected
  2766. * param exchange, choose the minimum */
  2767. if (mdev->state.conn == C_WF_REPORT_PARAMS)
  2768. p_usize = min_not_zero((sector_t)mdev->ldev->dc.disk_size,
  2769. p_usize);
  2770. my_usize = mdev->ldev->dc.disk_size;
  2771. if (mdev->ldev->dc.disk_size != p_usize) {
  2772. mdev->ldev->dc.disk_size = p_usize;
  2773. dev_info(DEV, "Peer sets u_size to %lu sectors\n",
  2774. (unsigned long)mdev->ldev->dc.disk_size);
  2775. }
  2776. /* Never shrink a device with usable data during connect.
  2777. But allow online shrinking if we are connected. */
  2778. if (drbd_new_dev_size(mdev, mdev->ldev, 0) <
  2779. drbd_get_capacity(mdev->this_bdev) &&
  2780. mdev->state.disk >= D_OUTDATED &&
  2781. mdev->state.conn < C_CONNECTED) {
  2782. dev_err(DEV, "The peer's disk size is too small!\n");
  2783. conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD);
  2784. mdev->ldev->dc.disk_size = my_usize;
  2785. put_ldev(mdev);
  2786. return -EIO;
  2787. }
  2788. put_ldev(mdev);
  2789. }
  2790. ddsf = be16_to_cpu(p->dds_flags);
  2791. if (get_ldev(mdev)) {
  2792. dd = drbd_determine_dev_size(mdev, ddsf);
  2793. put_ldev(mdev);
  2794. if (dd == dev_size_error)
  2795. return -EIO;
  2796. drbd_md_sync(mdev);
  2797. } else {
  2798. /* I am diskless, need to accept the peer's size. */
  2799. drbd_set_my_capacity(mdev, p_size);
  2800. }
  2801. mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size);
  2802. drbd_reconsider_max_bio_size(mdev);
  2803. if (get_ldev(mdev)) {
  2804. if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) {
  2805. mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev);
  2806. ldsc = 1;
  2807. }
  2808. put_ldev(mdev);
  2809. }
  2810. if (mdev->state.conn > C_WF_REPORT_PARAMS) {
  2811. if (be64_to_cpu(p->c_size) !=
  2812. drbd_get_capacity(mdev->this_bdev) || ldsc) {
  2813. /* we have different sizes, probably peer
  2814. * needs to know my new size... */
  2815. drbd_send_sizes(mdev, 0, ddsf);
  2816. }
  2817. if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) ||
  2818. (dd == grew && mdev->state.conn == C_CONNECTED)) {
  2819. if (mdev->state.pdsk >= D_INCONSISTENT &&
  2820. mdev->state.disk >= D_INCONSISTENT) {
  2821. if (ddsf & DDSF_NO_RESYNC)
  2822. dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n");
  2823. else
  2824. resync_after_online_grow(mdev);
  2825. } else
  2826. set_bit(RESYNC_AFTER_NEG, &mdev->flags);
  2827. }
  2828. }
  2829. return 0;
  2830. }
  2831. static int receive_uuids(struct drbd_tconn *tconn, struct packet_info *pi)
  2832. {
  2833. struct drbd_conf *mdev;
  2834. struct p_uuids *p = tconn->data.rbuf;
  2835. u64 *p_uuid;
  2836. int i, updated_uuids = 0;
  2837. mdev = vnr_to_mdev(tconn, pi->vnr);
  2838. if (!mdev)
  2839. return config_unknown_volume(tconn, pi);
  2840. p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO);
  2841. for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++)
  2842. p_uuid[i] = be64_to_cpu(p->uuid[i]);
  2843. kfree(mdev->p_uuid);
  2844. mdev->p_uuid = p_uuid;
  2845. if (mdev->state.conn < C_CONNECTED &&
  2846. mdev->state.disk < D_INCONSISTENT &&
  2847. mdev->state.role == R_PRIMARY &&
  2848. (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) {
  2849. dev_err(DEV, "Can only connect to data with current UUID=%016llX\n",
  2850. (unsigned long long)mdev->ed_uuid);
  2851. conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD);
  2852. return -EIO;
  2853. }
  2854. if (get_ldev(mdev)) {
  2855. int skip_initial_sync =
  2856. mdev->state.conn == C_CONNECTED &&
  2857. mdev->tconn->agreed_pro_version >= 90 &&
  2858. mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED &&
  2859. (p_uuid[UI_FLAGS] & 8);
  2860. if (skip_initial_sync) {
  2861. dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n");
  2862. drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write,
  2863. "clear_n_write from receive_uuids",
  2864. BM_LOCKED_TEST_ALLOWED);
  2865. _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]);
  2866. _drbd_uuid_set(mdev, UI_BITMAP, 0);
  2867. _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE),
  2868. CS_VERBOSE, NULL);
  2869. drbd_md_sync(mdev);
  2870. updated_uuids = 1;
  2871. }
  2872. put_ldev(mdev);
  2873. } else if (mdev->state.disk < D_INCONSISTENT &&
  2874. mdev->state.role == R_PRIMARY) {
  2875. /* I am a diskless primary, the peer just created a new current UUID
  2876. for me. */
  2877. updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]);
  2878. }
  2879. /* Before we test for the disk state, we should wait until an eventually
  2880. ongoing cluster wide state change is finished. That is important if
  2881. we are primary and are detaching from our disk. We need to see the
  2882. new disk state... */
  2883. mutex_lock(mdev->state_mutex);
  2884. mutex_unlock(mdev->state_mutex);
  2885. if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT)
  2886. updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]);
  2887. if (updated_uuids)
  2888. drbd_print_uuids(mdev, "receiver updated UUIDs to");
  2889. return 0;
  2890. }
  2891. /**
  2892. * convert_state() - Converts the peer's view of the cluster state to our point of view
  2893. * @ps: The state as seen by the peer.
  2894. */
  2895. static union drbd_state convert_state(union drbd_state ps)
  2896. {
  2897. union drbd_state ms;
  2898. static enum drbd_conns c_tab[] = {
  2899. [C_CONNECTED] = C_CONNECTED,
  2900. [C_STARTING_SYNC_S] = C_STARTING_SYNC_T,
  2901. [C_STARTING_SYNC_T] = C_STARTING_SYNC_S,
  2902. [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */
  2903. [C_VERIFY_S] = C_VERIFY_T,
  2904. [C_MASK] = C_MASK,
  2905. };
  2906. ms.i = ps.i;
  2907. ms.conn = c_tab[ps.conn];
  2908. ms.peer = ps.role;
  2909. ms.role = ps.peer;
  2910. ms.pdsk = ps.disk;
  2911. ms.disk = ps.pdsk;
  2912. ms.peer_isp = (ps.aftr_isp | ps.user_isp);
  2913. return ms;
  2914. }
  2915. static int receive_req_state(struct drbd_tconn *tconn, struct packet_info *pi)
  2916. {
  2917. struct drbd_conf *mdev;
  2918. struct p_req_state *p = tconn->data.rbuf;
  2919. union drbd_state mask, val;
  2920. enum drbd_state_rv rv;
  2921. mdev = vnr_to_mdev(tconn, pi->vnr);
  2922. if (!mdev)
  2923. return -EIO;
  2924. mask.i = be32_to_cpu(p->mask);
  2925. val.i = be32_to_cpu(p->val);
  2926. if (test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) &&
  2927. mutex_is_locked(mdev->state_mutex)) {
  2928. drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG);
  2929. return 0;
  2930. }
  2931. mask = convert_state(mask);
  2932. val = convert_state(val);
  2933. rv = drbd_change_state(mdev, CS_VERBOSE, mask, val);
  2934. drbd_send_sr_reply(mdev, rv);
  2935. drbd_md_sync(mdev);
  2936. return 0;
  2937. }
  2938. static int receive_req_conn_state(struct drbd_tconn *tconn, struct packet_info *pi)
  2939. {
  2940. struct p_req_state *p = tconn->data.rbuf;
  2941. union drbd_state mask, val;
  2942. enum drbd_state_rv rv;
  2943. mask.i = be32_to_cpu(p->mask);
  2944. val.i = be32_to_cpu(p->val);
  2945. if (test_bit(DISCARD_CONCURRENT, &tconn->flags) &&
  2946. mutex_is_locked(&tconn->cstate_mutex)) {
  2947. conn_send_sr_reply(tconn, SS_CONCURRENT_ST_CHG);
  2948. return 0;
  2949. }
  2950. mask = convert_state(mask);
  2951. val = convert_state(val);
  2952. rv = conn_request_state(tconn, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL);
  2953. conn_send_sr_reply(tconn, rv);
  2954. return 0;
  2955. }
  2956. static int receive_state(struct drbd_tconn *tconn, struct packet_info *pi)
  2957. {
  2958. struct drbd_conf *mdev;
  2959. struct p_state *p = tconn->data.rbuf;
  2960. union drbd_state os, ns, peer_state;
  2961. enum drbd_disk_state real_peer_disk;
  2962. enum chg_state_flags cs_flags;
  2963. int rv;
  2964. mdev = vnr_to_mdev(tconn, pi->vnr);
  2965. if (!mdev)
  2966. return config_unknown_volume(tconn, pi);
  2967. peer_state.i = be32_to_cpu(p->state);
  2968. real_peer_disk = peer_state.disk;
  2969. if (peer_state.disk == D_NEGOTIATING) {
  2970. real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT;
  2971. dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk));
  2972. }
  2973. spin_lock_irq(&mdev->tconn->req_lock);
  2974. retry:
  2975. os = ns = mdev->state;
  2976. spin_unlock_irq(&mdev->tconn->req_lock);
  2977. /* peer says his disk is uptodate, while we think it is inconsistent,
  2978. * and this happens while we think we have a sync going on. */
  2979. if (os.pdsk == D_INCONSISTENT && real_peer_disk == D_UP_TO_DATE &&
  2980. os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) {
  2981. /* If we are (becoming) SyncSource, but peer is still in sync
  2982. * preparation, ignore its uptodate-ness to avoid flapping, it
  2983. * will change to inconsistent once the peer reaches active
  2984. * syncing states.
  2985. * It may have changed syncer-paused flags, however, so we
  2986. * cannot ignore this completely. */
  2987. if (peer_state.conn > C_CONNECTED &&
  2988. peer_state.conn < C_SYNC_SOURCE)
  2989. real_peer_disk = D_INCONSISTENT;
  2990. /* if peer_state changes to connected at the same time,
  2991. * it explicitly notifies us that it finished resync.
  2992. * Maybe we should finish it up, too? */
  2993. else if (os.conn >= C_SYNC_SOURCE &&
  2994. peer_state.conn == C_CONNECTED) {
  2995. if (drbd_bm_total_weight(mdev) <= mdev->rs_failed)
  2996. drbd_resync_finished(mdev);
  2997. return 0;
  2998. }
  2999. }
  3000. /* peer says his disk is inconsistent, while we think it is uptodate,
  3001. * and this happens while the peer still thinks we have a sync going on,
  3002. * but we think we are already done with the sync.
  3003. * We ignore this to avoid flapping pdsk.
  3004. * This should not happen, if the peer is a recent version of drbd. */
  3005. if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT &&
  3006. os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE)
  3007. real_peer_disk = D_UP_TO_DATE;
  3008. if (ns.conn == C_WF_REPORT_PARAMS)
  3009. ns.conn = C_CONNECTED;
  3010. if (peer_state.conn == C_AHEAD)
  3011. ns.conn = C_BEHIND;
  3012. if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING &&
  3013. get_ldev_if_state(mdev, D_NEGOTIATING)) {
  3014. int cr; /* consider resync */
  3015. /* if we established a new connection */
  3016. cr = (os.conn < C_CONNECTED);
  3017. /* if we had an established connection
  3018. * and one of the nodes newly attaches a disk */
  3019. cr |= (os.conn == C_CONNECTED &&
  3020. (peer_state.disk == D_NEGOTIATING ||
  3021. os.disk == D_NEGOTIATING));
  3022. /* if we have both been inconsistent, and the peer has been
  3023. * forced to be UpToDate with --overwrite-data */
  3024. cr |= test_bit(CONSIDER_RESYNC, &mdev->flags);
  3025. /* if we had been plain connected, and the admin requested to
  3026. * start a sync by "invalidate" or "invalidate-remote" */
  3027. cr |= (os.conn == C_CONNECTED &&
  3028. (peer_state.conn >= C_STARTING_SYNC_S &&
  3029. peer_state.conn <= C_WF_BITMAP_T));
  3030. if (cr)
  3031. ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk);
  3032. put_ldev(mdev);
  3033. if (ns.conn == C_MASK) {
  3034. ns.conn = C_CONNECTED;
  3035. if (mdev->state.disk == D_NEGOTIATING) {
  3036. drbd_force_state(mdev, NS(disk, D_FAILED));
  3037. } else if (peer_state.disk == D_NEGOTIATING) {
  3038. dev_err(DEV, "Disk attach process on the peer node was aborted.\n");
  3039. peer_state.disk = D_DISKLESS;
  3040. real_peer_disk = D_DISKLESS;
  3041. } else {
  3042. if (test_and_clear_bit(CONN_DRY_RUN, &mdev->tconn->flags))
  3043. return -EIO;
  3044. D_ASSERT(os.conn == C_WF_REPORT_PARAMS);
  3045. conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD);
  3046. return -EIO;
  3047. }
  3048. }
  3049. }
  3050. spin_lock_irq(&mdev->tconn->req_lock);
  3051. if (mdev->state.i != os.i)
  3052. goto retry;
  3053. clear_bit(CONSIDER_RESYNC, &mdev->flags);
  3054. ns.peer = peer_state.role;
  3055. ns.pdsk = real_peer_disk;
  3056. ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp);
  3057. if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING)
  3058. ns.disk = mdev->new_state_tmp.disk;
  3059. cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD);
  3060. if (ns.pdsk == D_CONSISTENT && is_susp(ns) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED &&
  3061. test_bit(NEW_CUR_UUID, &mdev->flags)) {
  3062. /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this
  3063. for temporal network outages! */
  3064. spin_unlock_irq(&mdev->tconn->req_lock);
  3065. dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n");
  3066. tl_clear(mdev->tconn);
  3067. drbd_uuid_new_current(mdev);
  3068. clear_bit(NEW_CUR_UUID, &mdev->flags);
  3069. conn_request_state(mdev->tconn, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD);
  3070. return -EIO;
  3071. }
  3072. rv = _drbd_set_state(mdev, ns, cs_flags, NULL);
  3073. ns = mdev->state;
  3074. spin_unlock_irq(&mdev->tconn->req_lock);
  3075. if (rv < SS_SUCCESS) {
  3076. conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD);
  3077. return -EIO;
  3078. }
  3079. if (os.conn > C_WF_REPORT_PARAMS) {
  3080. if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED &&
  3081. peer_state.disk != D_NEGOTIATING ) {
  3082. /* we want resync, peer has not yet decided to sync... */
  3083. /* Nowadays only used when forcing a node into primary role and
  3084. setting its disk to UpToDate with that */
  3085. drbd_send_uuids(mdev);
  3086. drbd_send_state(mdev);
  3087. }
  3088. }
  3089. mdev->tconn->net_conf->want_lose = 0;
  3090. drbd_md_sync(mdev); /* update connected indicator, la_size, ... */
  3091. return 0;
  3092. }
  3093. static int receive_sync_uuid(struct drbd_tconn *tconn, struct packet_info *pi)
  3094. {
  3095. struct drbd_conf *mdev;
  3096. struct p_rs_uuid *p = tconn->data.rbuf;
  3097. mdev = vnr_to_mdev(tconn, pi->vnr);
  3098. if (!mdev)
  3099. return -EIO;
  3100. wait_event(mdev->misc_wait,
  3101. mdev->state.conn == C_WF_SYNC_UUID ||
  3102. mdev->state.conn == C_BEHIND ||
  3103. mdev->state.conn < C_CONNECTED ||
  3104. mdev->state.disk < D_NEGOTIATING);
  3105. /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */
  3106. /* Here the _drbd_uuid_ functions are right, current should
  3107. _not_ be rotated into the history */
  3108. if (get_ldev_if_state(mdev, D_NEGOTIATING)) {
  3109. _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid));
  3110. _drbd_uuid_set(mdev, UI_BITMAP, 0UL);
  3111. drbd_print_uuids(mdev, "updated sync uuid");
  3112. drbd_start_resync(mdev, C_SYNC_TARGET);
  3113. put_ldev(mdev);
  3114. } else
  3115. dev_err(DEV, "Ignoring SyncUUID packet!\n");
  3116. return 0;
  3117. }
  3118. /**
  3119. * receive_bitmap_plain
  3120. *
  3121. * Return 0 when done, 1 when another iteration is needed, and a negative error
  3122. * code upon failure.
  3123. */
  3124. static int
  3125. receive_bitmap_plain(struct drbd_conf *mdev, unsigned int data_size,
  3126. struct p_header *h, struct bm_xfer_ctx *c)
  3127. {
  3128. unsigned long *buffer = (unsigned long *)h->payload;
  3129. unsigned num_words = min_t(size_t, BM_PACKET_WORDS, c->bm_words - c->word_offset);
  3130. unsigned want = num_words * sizeof(long);
  3131. int err;
  3132. if (want != data_size) {
  3133. dev_err(DEV, "%s:want (%u) != data_size (%u)\n", __func__, want, data_size);
  3134. return -EIO;
  3135. }
  3136. if (want == 0)
  3137. return 0;
  3138. err = drbd_recv_all(mdev->tconn, buffer, want);
  3139. if (err)
  3140. return err;
  3141. drbd_bm_merge_lel(mdev, c->word_offset, num_words, buffer);
  3142. c->word_offset += num_words;
  3143. c->bit_offset = c->word_offset * BITS_PER_LONG;
  3144. if (c->bit_offset > c->bm_bits)
  3145. c->bit_offset = c->bm_bits;
  3146. return 1;
  3147. }
  3148. static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p)
  3149. {
  3150. return (enum drbd_bitmap_code)(p->encoding & 0x0f);
  3151. }
  3152. static int dcbp_get_start(struct p_compressed_bm *p)
  3153. {
  3154. return (p->encoding & 0x80) != 0;
  3155. }
  3156. static int dcbp_get_pad_bits(struct p_compressed_bm *p)
  3157. {
  3158. return (p->encoding >> 4) & 0x7;
  3159. }
  3160. /**
  3161. * recv_bm_rle_bits
  3162. *
  3163. * Return 0 when done, 1 when another iteration is needed, and a negative error
  3164. * code upon failure.
  3165. */
  3166. static int
  3167. recv_bm_rle_bits(struct drbd_conf *mdev,
  3168. struct p_compressed_bm *p,
  3169. struct bm_xfer_ctx *c,
  3170. unsigned int len)
  3171. {
  3172. struct bitstream bs;
  3173. u64 look_ahead;
  3174. u64 rl;
  3175. u64 tmp;
  3176. unsigned long s = c->bit_offset;
  3177. unsigned long e;
  3178. int toggle = dcbp_get_start(p);
  3179. int have;
  3180. int bits;
  3181. bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p));
  3182. bits = bitstream_get_bits(&bs, &look_ahead, 64);
  3183. if (bits < 0)
  3184. return -EIO;
  3185. for (have = bits; have > 0; s += rl, toggle = !toggle) {
  3186. bits = vli_decode_bits(&rl, look_ahead);
  3187. if (bits <= 0)
  3188. return -EIO;
  3189. if (toggle) {
  3190. e = s + rl -1;
  3191. if (e >= c->bm_bits) {
  3192. dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e);
  3193. return -EIO;
  3194. }
  3195. _drbd_bm_set_bits(mdev, s, e);
  3196. }
  3197. if (have < bits) {
  3198. dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n",
  3199. have, bits, look_ahead,
  3200. (unsigned int)(bs.cur.b - p->code),
  3201. (unsigned int)bs.buf_len);
  3202. return -EIO;
  3203. }
  3204. look_ahead >>= bits;
  3205. have -= bits;
  3206. bits = bitstream_get_bits(&bs, &tmp, 64 - have);
  3207. if (bits < 0)
  3208. return -EIO;
  3209. look_ahead |= tmp << have;
  3210. have += bits;
  3211. }
  3212. c->bit_offset = s;
  3213. bm_xfer_ctx_bit_to_word_offset(c);
  3214. return (s != c->bm_bits);
  3215. }
  3216. /**
  3217. * decode_bitmap_c
  3218. *
  3219. * Return 0 when done, 1 when another iteration is needed, and a negative error
  3220. * code upon failure.
  3221. */
  3222. static int
  3223. decode_bitmap_c(struct drbd_conf *mdev,
  3224. struct p_compressed_bm *p,
  3225. struct bm_xfer_ctx *c,
  3226. unsigned int len)
  3227. {
  3228. if (dcbp_get_code(p) == RLE_VLI_Bits)
  3229. return recv_bm_rle_bits(mdev, p, c, len);
  3230. /* other variants had been implemented for evaluation,
  3231. * but have been dropped as this one turned out to be "best"
  3232. * during all our tests. */
  3233. dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding);
  3234. conn_request_state(mdev->tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD);
  3235. return -EIO;
  3236. }
  3237. void INFO_bm_xfer_stats(struct drbd_conf *mdev,
  3238. const char *direction, struct bm_xfer_ctx *c)
  3239. {
  3240. /* what would it take to transfer it "plaintext" */
  3241. unsigned plain = sizeof(struct p_header) *
  3242. ((c->bm_words+BM_PACKET_WORDS-1)/BM_PACKET_WORDS+1)
  3243. + c->bm_words * sizeof(long);
  3244. unsigned total = c->bytes[0] + c->bytes[1];
  3245. unsigned r;
  3246. /* total can not be zero. but just in case: */
  3247. if (total == 0)
  3248. return;
  3249. /* don't report if not compressed */
  3250. if (total >= plain)
  3251. return;
  3252. /* total < plain. check for overflow, still */
  3253. r = (total > UINT_MAX/1000) ? (total / (plain/1000))
  3254. : (1000 * total / plain);
  3255. if (r > 1000)
  3256. r = 1000;
  3257. r = 1000 - r;
  3258. dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), "
  3259. "total %u; compression: %u.%u%%\n",
  3260. direction,
  3261. c->bytes[1], c->packets[1],
  3262. c->bytes[0], c->packets[0],
  3263. total, r/10, r % 10);
  3264. }
  3265. /* Since we are processing the bitfield from lower addresses to higher,
  3266. it does not matter if the process it in 32 bit chunks or 64 bit
  3267. chunks as long as it is little endian. (Understand it as byte stream,
  3268. beginning with the lowest byte...) If we would use big endian
  3269. we would need to process it from the highest address to the lowest,
  3270. in order to be agnostic to the 32 vs 64 bits issue.
  3271. returns 0 on failure, 1 if we successfully received it. */
  3272. static int receive_bitmap(struct drbd_tconn *tconn, struct packet_info *pi)
  3273. {
  3274. struct drbd_conf *mdev;
  3275. struct bm_xfer_ctx c;
  3276. int err;
  3277. struct p_header *h = tconn->data.rbuf;
  3278. mdev = vnr_to_mdev(tconn, pi->vnr);
  3279. if (!mdev)
  3280. return -EIO;
  3281. drbd_bm_lock(mdev, "receive bitmap", BM_LOCKED_SET_ALLOWED);
  3282. /* you are supposed to send additional out-of-sync information
  3283. * if you actually set bits during this phase */
  3284. c = (struct bm_xfer_ctx) {
  3285. .bm_bits = drbd_bm_bits(mdev),
  3286. .bm_words = drbd_bm_words(mdev),
  3287. };
  3288. for(;;) {
  3289. if (pi->cmd == P_BITMAP) {
  3290. err = receive_bitmap_plain(mdev, pi->size, h, &c);
  3291. } else if (pi->cmd == P_COMPRESSED_BITMAP) {
  3292. /* MAYBE: sanity check that we speak proto >= 90,
  3293. * and the feature is enabled! */
  3294. struct p_compressed_bm *p;
  3295. if (pi->size > BM_PACKET_PAYLOAD_BYTES) {
  3296. dev_err(DEV, "ReportCBitmap packet too large\n");
  3297. err = -EIO;
  3298. goto out;
  3299. }
  3300. p = mdev->tconn->data.rbuf;
  3301. err = drbd_recv_all(mdev->tconn, p->head.payload, pi->size);
  3302. if (err)
  3303. goto out;
  3304. if (pi->size <= (sizeof(*p) - sizeof(p->head))) {
  3305. dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", pi->size);
  3306. err = -EIO;
  3307. goto out;
  3308. }
  3309. err = decode_bitmap_c(mdev, p, &c, pi->size);
  3310. } else {
  3311. dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd);
  3312. err = -EIO;
  3313. goto out;
  3314. }
  3315. c.packets[pi->cmd == P_BITMAP]++;
  3316. c.bytes[pi->cmd == P_BITMAP] += sizeof(struct p_header) + pi->size;
  3317. if (err <= 0) {
  3318. if (err < 0)
  3319. goto out;
  3320. break;
  3321. }
  3322. err = drbd_recv_header(mdev->tconn, pi);
  3323. if (err)
  3324. goto out;
  3325. }
  3326. INFO_bm_xfer_stats(mdev, "receive", &c);
  3327. if (mdev->state.conn == C_WF_BITMAP_T) {
  3328. enum drbd_state_rv rv;
  3329. err = drbd_send_bitmap(mdev);
  3330. if (err)
  3331. goto out;
  3332. /* Omit CS_ORDERED with this state transition to avoid deadlocks. */
  3333. rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE);
  3334. D_ASSERT(rv == SS_SUCCESS);
  3335. } else if (mdev->state.conn != C_WF_BITMAP_S) {
  3336. /* admin may have requested C_DISCONNECTING,
  3337. * other threads may have noticed network errors */
  3338. dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n",
  3339. drbd_conn_str(mdev->state.conn));
  3340. }
  3341. err = 0;
  3342. out:
  3343. drbd_bm_unlock(mdev);
  3344. if (!err && mdev->state.conn == C_WF_BITMAP_S)
  3345. drbd_start_resync(mdev, C_SYNC_SOURCE);
  3346. return err;
  3347. }
  3348. static int receive_skip(struct drbd_tconn *tconn, struct packet_info *pi)
  3349. {
  3350. conn_warn(tconn, "skipping unknown optional packet type %d, l: %d!\n",
  3351. pi->cmd, pi->size);
  3352. return ignore_remaining_packet(tconn, pi);
  3353. }
  3354. static int receive_UnplugRemote(struct drbd_tconn *tconn, struct packet_info *pi)
  3355. {
  3356. /* Make sure we've acked all the TCP data associated
  3357. * with the data requests being unplugged */
  3358. drbd_tcp_quickack(tconn->data.socket);
  3359. return 0;
  3360. }
  3361. static int receive_out_of_sync(struct drbd_tconn *tconn, struct packet_info *pi)
  3362. {
  3363. struct drbd_conf *mdev;
  3364. struct p_block_desc *p = tconn->data.rbuf;
  3365. mdev = vnr_to_mdev(tconn, pi->vnr);
  3366. if (!mdev)
  3367. return -EIO;
  3368. switch (mdev->state.conn) {
  3369. case C_WF_SYNC_UUID:
  3370. case C_WF_BITMAP_T:
  3371. case C_BEHIND:
  3372. break;
  3373. default:
  3374. dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n",
  3375. drbd_conn_str(mdev->state.conn));
  3376. }
  3377. drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize));
  3378. return 0;
  3379. }
  3380. struct data_cmd {
  3381. int expect_payload;
  3382. size_t pkt_size;
  3383. int (*fn)(struct drbd_tconn *, struct packet_info *);
  3384. };
  3385. static struct data_cmd drbd_cmd_handler[] = {
  3386. [P_DATA] = { 1, sizeof(struct p_data), receive_Data },
  3387. [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply },
  3388. [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } ,
  3389. [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } ,
  3390. [P_BITMAP] = { 1, sizeof(struct p_header), receive_bitmap } ,
  3391. [P_COMPRESSED_BITMAP] = { 1, sizeof(struct p_header), receive_bitmap } ,
  3392. [P_UNPLUG_REMOTE] = { 0, sizeof(struct p_header), receive_UnplugRemote },
  3393. [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest },
  3394. [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest },
  3395. [P_SYNC_PARAM] = { 1, sizeof(struct p_header), receive_SyncParam },
  3396. [P_SYNC_PARAM89] = { 1, sizeof(struct p_header), receive_SyncParam },
  3397. [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol },
  3398. [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids },
  3399. [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes },
  3400. [P_STATE] = { 0, sizeof(struct p_state), receive_state },
  3401. [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state },
  3402. [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid },
  3403. [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest },
  3404. [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest },
  3405. [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest },
  3406. [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip },
  3407. [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync },
  3408. [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state },
  3409. };
  3410. static void drbdd(struct drbd_tconn *tconn)
  3411. {
  3412. struct p_header *header = tconn->data.rbuf;
  3413. struct packet_info pi;
  3414. size_t shs; /* sub header size */
  3415. int err;
  3416. while (get_t_state(&tconn->receiver) == RUNNING) {
  3417. struct data_cmd *cmd;
  3418. drbd_thread_current_set_cpu(&tconn->receiver);
  3419. if (drbd_recv_header(tconn, &pi))
  3420. goto err_out;
  3421. cmd = &drbd_cmd_handler[pi.cmd];
  3422. if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) {
  3423. conn_err(tconn, "unknown packet type %d, l: %d!\n", pi.cmd, pi.size);
  3424. goto err_out;
  3425. }
  3426. shs = cmd->pkt_size - sizeof(struct p_header);
  3427. if (pi.size - shs > 0 && !cmd->expect_payload) {
  3428. conn_err(tconn, "No payload expected %s l:%d\n", cmdname(pi.cmd), pi.size);
  3429. goto err_out;
  3430. }
  3431. if (shs) {
  3432. err = drbd_recv_all_warn(tconn, &header->payload, shs);
  3433. if (err)
  3434. goto err_out;
  3435. pi.size -= shs;
  3436. }
  3437. err = cmd->fn(tconn, &pi);
  3438. if (err) {
  3439. conn_err(tconn, "error receiving %s, l: %d!\n",
  3440. cmdname(pi.cmd), pi.size);
  3441. goto err_out;
  3442. }
  3443. }
  3444. return;
  3445. err_out:
  3446. conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD);
  3447. }
  3448. void conn_flush_workqueue(struct drbd_tconn *tconn)
  3449. {
  3450. struct drbd_wq_barrier barr;
  3451. barr.w.cb = w_prev_work_done;
  3452. barr.w.tconn = tconn;
  3453. init_completion(&barr.done);
  3454. drbd_queue_work(&tconn->data.work, &barr.w);
  3455. wait_for_completion(&barr.done);
  3456. }
  3457. static void drbd_disconnect(struct drbd_tconn *tconn)
  3458. {
  3459. enum drbd_conns oc;
  3460. int rv = SS_UNKNOWN_ERROR;
  3461. if (tconn->cstate == C_STANDALONE)
  3462. return;
  3463. /* asender does not clean up anything. it must not interfere, either */
  3464. drbd_thread_stop(&tconn->asender);
  3465. drbd_free_sock(tconn);
  3466. idr_for_each(&tconn->volumes, drbd_disconnected, tconn);
  3467. conn_info(tconn, "Connection closed\n");
  3468. if (conn_highest_role(tconn) == R_PRIMARY && conn_highest_pdsk(tconn) >= D_UNKNOWN)
  3469. conn_try_outdate_peer_async(tconn);
  3470. spin_lock_irq(&tconn->req_lock);
  3471. oc = tconn->cstate;
  3472. if (oc >= C_UNCONNECTED)
  3473. rv = _conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE);
  3474. spin_unlock_irq(&tconn->req_lock);
  3475. if (oc == C_DISCONNECTING) {
  3476. wait_event(tconn->net_cnt_wait, atomic_read(&tconn->net_cnt) == 0);
  3477. crypto_free_hash(tconn->cram_hmac_tfm);
  3478. tconn->cram_hmac_tfm = NULL;
  3479. kfree(tconn->net_conf);
  3480. tconn->net_conf = NULL;
  3481. conn_request_state(tconn, NS(conn, C_STANDALONE), CS_VERBOSE);
  3482. }
  3483. }
  3484. static int drbd_disconnected(int vnr, void *p, void *data)
  3485. {
  3486. struct drbd_conf *mdev = (struct drbd_conf *)p;
  3487. enum drbd_fencing_p fp;
  3488. unsigned int i;
  3489. /* wait for current activity to cease. */
  3490. spin_lock_irq(&mdev->tconn->req_lock);
  3491. _drbd_wait_ee_list_empty(mdev, &mdev->active_ee);
  3492. _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee);
  3493. _drbd_wait_ee_list_empty(mdev, &mdev->read_ee);
  3494. spin_unlock_irq(&mdev->tconn->req_lock);
  3495. /* We do not have data structures that would allow us to
  3496. * get the rs_pending_cnt down to 0 again.
  3497. * * On C_SYNC_TARGET we do not have any data structures describing
  3498. * the pending RSDataRequest's we have sent.
  3499. * * On C_SYNC_SOURCE there is no data structure that tracks
  3500. * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget.
  3501. * And no, it is not the sum of the reference counts in the
  3502. * resync_LRU. The resync_LRU tracks the whole operation including
  3503. * the disk-IO, while the rs_pending_cnt only tracks the blocks
  3504. * on the fly. */
  3505. drbd_rs_cancel_all(mdev);
  3506. mdev->rs_total = 0;
  3507. mdev->rs_failed = 0;
  3508. atomic_set(&mdev->rs_pending_cnt, 0);
  3509. wake_up(&mdev->misc_wait);
  3510. del_timer(&mdev->request_timer);
  3511. del_timer_sync(&mdev->resync_timer);
  3512. resync_timer_fn((unsigned long)mdev);
  3513. /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier,
  3514. * w_make_resync_request etc. which may still be on the worker queue
  3515. * to be "canceled" */
  3516. drbd_flush_workqueue(mdev);
  3517. /* This also does reclaim_net_ee(). If we do this too early, we might
  3518. * miss some resync ee and pages.*/
  3519. drbd_process_done_ee(mdev);
  3520. kfree(mdev->p_uuid);
  3521. mdev->p_uuid = NULL;
  3522. if (!is_susp(mdev->state))
  3523. tl_clear(mdev->tconn);
  3524. drbd_md_sync(mdev);
  3525. fp = FP_DONT_CARE;
  3526. if (get_ldev(mdev)) {
  3527. fp = mdev->ldev->dc.fencing;
  3528. put_ldev(mdev);
  3529. }
  3530. /* serialize with bitmap writeout triggered by the state change,
  3531. * if any. */
  3532. wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
  3533. /* tcp_close and release of sendpage pages can be deferred. I don't
  3534. * want to use SO_LINGER, because apparently it can be deferred for
  3535. * more than 20 seconds (longest time I checked).
  3536. *
  3537. * Actually we don't care for exactly when the network stack does its
  3538. * put_page(), but release our reference on these pages right here.
  3539. */
  3540. i = drbd_release_ee(mdev, &mdev->net_ee);
  3541. if (i)
  3542. dev_info(DEV, "net_ee not empty, killed %u entries\n", i);
  3543. i = atomic_read(&mdev->pp_in_use_by_net);
  3544. if (i)
  3545. dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i);
  3546. i = atomic_read(&mdev->pp_in_use);
  3547. if (i)
  3548. dev_info(DEV, "pp_in_use = %d, expected 0\n", i);
  3549. D_ASSERT(list_empty(&mdev->read_ee));
  3550. D_ASSERT(list_empty(&mdev->active_ee));
  3551. D_ASSERT(list_empty(&mdev->sync_ee));
  3552. D_ASSERT(list_empty(&mdev->done_ee));
  3553. /* ok, no more ee's on the fly, it is safe to reset the epoch_size */
  3554. atomic_set(&mdev->current_epoch->epoch_size, 0);
  3555. D_ASSERT(list_empty(&mdev->current_epoch->list));
  3556. return 0;
  3557. }
  3558. /*
  3559. * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version
  3560. * we can agree on is stored in agreed_pro_version.
  3561. *
  3562. * feature flags and the reserved array should be enough room for future
  3563. * enhancements of the handshake protocol, and possible plugins...
  3564. *
  3565. * for now, they are expected to be zero, but ignored.
  3566. */
  3567. static int drbd_send_handshake(struct drbd_tconn *tconn)
  3568. {
  3569. /* ASSERT current == mdev->tconn->receiver ... */
  3570. struct p_handshake *p = tconn->data.sbuf;
  3571. int err;
  3572. if (mutex_lock_interruptible(&tconn->data.mutex)) {
  3573. conn_err(tconn, "interrupted during initial handshake\n");
  3574. return -EINTR;
  3575. }
  3576. if (tconn->data.socket == NULL) {
  3577. mutex_unlock(&tconn->data.mutex);
  3578. return -EIO;
  3579. }
  3580. memset(p, 0, sizeof(*p));
  3581. p->protocol_min = cpu_to_be32(PRO_VERSION_MIN);
  3582. p->protocol_max = cpu_to_be32(PRO_VERSION_MAX);
  3583. err = _conn_send_cmd(tconn, 0, &tconn->data, P_HAND_SHAKE,
  3584. &p->head, sizeof(*p), 0);
  3585. mutex_unlock(&tconn->data.mutex);
  3586. return err;
  3587. }
  3588. /*
  3589. * return values:
  3590. * 1 yes, we have a valid connection
  3591. * 0 oops, did not work out, please try again
  3592. * -1 peer talks different language,
  3593. * no point in trying again, please go standalone.
  3594. */
  3595. static int drbd_do_handshake(struct drbd_tconn *tconn)
  3596. {
  3597. /* ASSERT current == tconn->receiver ... */
  3598. struct p_handshake *p = tconn->data.rbuf;
  3599. const int expect = sizeof(struct p_handshake) - sizeof(struct p_header80);
  3600. struct packet_info pi;
  3601. int err;
  3602. err = drbd_send_handshake(tconn);
  3603. if (err)
  3604. return 0;
  3605. err = drbd_recv_header(tconn, &pi);
  3606. if (err)
  3607. return 0;
  3608. if (pi.cmd != P_HAND_SHAKE) {
  3609. conn_err(tconn, "expected HandShake packet, received: %s (0x%04x)\n",
  3610. cmdname(pi.cmd), pi.cmd);
  3611. return -1;
  3612. }
  3613. if (pi.size != expect) {
  3614. conn_err(tconn, "expected HandShake length: %u, received: %u\n",
  3615. expect, pi.size);
  3616. return -1;
  3617. }
  3618. err = drbd_recv_all_warn(tconn, &p->head.payload, expect);
  3619. if (err)
  3620. return 0;
  3621. p->protocol_min = be32_to_cpu(p->protocol_min);
  3622. p->protocol_max = be32_to_cpu(p->protocol_max);
  3623. if (p->protocol_max == 0)
  3624. p->protocol_max = p->protocol_min;
  3625. if (PRO_VERSION_MAX < p->protocol_min ||
  3626. PRO_VERSION_MIN > p->protocol_max)
  3627. goto incompat;
  3628. tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max);
  3629. conn_info(tconn, "Handshake successful: "
  3630. "Agreed network protocol version %d\n", tconn->agreed_pro_version);
  3631. return 1;
  3632. incompat:
  3633. conn_err(tconn, "incompatible DRBD dialects: "
  3634. "I support %d-%d, peer supports %d-%d\n",
  3635. PRO_VERSION_MIN, PRO_VERSION_MAX,
  3636. p->protocol_min, p->protocol_max);
  3637. return -1;
  3638. }
  3639. #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE)
  3640. static int drbd_do_auth(struct drbd_tconn *tconn)
  3641. {
  3642. dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n");
  3643. dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n");
  3644. return -1;
  3645. }
  3646. #else
  3647. #define CHALLENGE_LEN 64
  3648. /* Return value:
  3649. 1 - auth succeeded,
  3650. 0 - failed, try again (network error),
  3651. -1 - auth failed, don't try again.
  3652. */
  3653. static int drbd_do_auth(struct drbd_tconn *tconn)
  3654. {
  3655. char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */
  3656. struct scatterlist sg;
  3657. char *response = NULL;
  3658. char *right_response = NULL;
  3659. char *peers_ch = NULL;
  3660. unsigned int key_len = strlen(tconn->net_conf->shared_secret);
  3661. unsigned int resp_size;
  3662. struct hash_desc desc;
  3663. struct packet_info pi;
  3664. int err, rv;
  3665. desc.tfm = tconn->cram_hmac_tfm;
  3666. desc.flags = 0;
  3667. rv = crypto_hash_setkey(tconn->cram_hmac_tfm,
  3668. (u8 *)tconn->net_conf->shared_secret, key_len);
  3669. if (rv) {
  3670. conn_err(tconn, "crypto_hash_setkey() failed with %d\n", rv);
  3671. rv = -1;
  3672. goto fail;
  3673. }
  3674. get_random_bytes(my_challenge, CHALLENGE_LEN);
  3675. rv = !conn_send_cmd2(tconn, P_AUTH_CHALLENGE, my_challenge, CHALLENGE_LEN);
  3676. if (!rv)
  3677. goto fail;
  3678. err = drbd_recv_header(tconn, &pi);
  3679. if (err) {
  3680. rv = 0;
  3681. goto fail;
  3682. }
  3683. if (pi.cmd != P_AUTH_CHALLENGE) {
  3684. conn_err(tconn, "expected AuthChallenge packet, received: %s (0x%04x)\n",
  3685. cmdname(pi.cmd), pi.cmd);
  3686. rv = 0;
  3687. goto fail;
  3688. }
  3689. if (pi.size > CHALLENGE_LEN * 2) {
  3690. conn_err(tconn, "expected AuthChallenge payload too big.\n");
  3691. rv = -1;
  3692. goto fail;
  3693. }
  3694. peers_ch = kmalloc(pi.size, GFP_NOIO);
  3695. if (peers_ch == NULL) {
  3696. conn_err(tconn, "kmalloc of peers_ch failed\n");
  3697. rv = -1;
  3698. goto fail;
  3699. }
  3700. err = drbd_recv_all_warn(tconn, peers_ch, pi.size);
  3701. if (err) {
  3702. rv = 0;
  3703. goto fail;
  3704. }
  3705. resp_size = crypto_hash_digestsize(tconn->cram_hmac_tfm);
  3706. response = kmalloc(resp_size, GFP_NOIO);
  3707. if (response == NULL) {
  3708. conn_err(tconn, "kmalloc of response failed\n");
  3709. rv = -1;
  3710. goto fail;
  3711. }
  3712. sg_init_table(&sg, 1);
  3713. sg_set_buf(&sg, peers_ch, pi.size);
  3714. rv = crypto_hash_digest(&desc, &sg, sg.length, response);
  3715. if (rv) {
  3716. conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv);
  3717. rv = -1;
  3718. goto fail;
  3719. }
  3720. rv = !conn_send_cmd2(tconn, P_AUTH_RESPONSE, response, resp_size);
  3721. if (!rv)
  3722. goto fail;
  3723. err = drbd_recv_header(tconn, &pi);
  3724. if (err) {
  3725. rv = 0;
  3726. goto fail;
  3727. }
  3728. if (pi.cmd != P_AUTH_RESPONSE) {
  3729. conn_err(tconn, "expected AuthResponse packet, received: %s (0x%04x)\n",
  3730. cmdname(pi.cmd), pi.cmd);
  3731. rv = 0;
  3732. goto fail;
  3733. }
  3734. if (pi.size != resp_size) {
  3735. conn_err(tconn, "expected AuthResponse payload of wrong size\n");
  3736. rv = 0;
  3737. goto fail;
  3738. }
  3739. err = drbd_recv_all_warn(tconn, response , resp_size);
  3740. if (err) {
  3741. rv = 0;
  3742. goto fail;
  3743. }
  3744. right_response = kmalloc(resp_size, GFP_NOIO);
  3745. if (right_response == NULL) {
  3746. conn_err(tconn, "kmalloc of right_response failed\n");
  3747. rv = -1;
  3748. goto fail;
  3749. }
  3750. sg_set_buf(&sg, my_challenge, CHALLENGE_LEN);
  3751. rv = crypto_hash_digest(&desc, &sg, sg.length, right_response);
  3752. if (rv) {
  3753. conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv);
  3754. rv = -1;
  3755. goto fail;
  3756. }
  3757. rv = !memcmp(response, right_response, resp_size);
  3758. if (rv)
  3759. conn_info(tconn, "Peer authenticated using %d bytes of '%s' HMAC\n",
  3760. resp_size, tconn->net_conf->cram_hmac_alg);
  3761. else
  3762. rv = -1;
  3763. fail:
  3764. kfree(peers_ch);
  3765. kfree(response);
  3766. kfree(right_response);
  3767. return rv;
  3768. }
  3769. #endif
  3770. int drbdd_init(struct drbd_thread *thi)
  3771. {
  3772. struct drbd_tconn *tconn = thi->tconn;
  3773. int h;
  3774. conn_info(tconn, "receiver (re)started\n");
  3775. do {
  3776. h = drbd_connect(tconn);
  3777. if (h == 0) {
  3778. drbd_disconnect(tconn);
  3779. schedule_timeout_interruptible(HZ);
  3780. }
  3781. if (h == -1) {
  3782. conn_warn(tconn, "Discarding network configuration.\n");
  3783. conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD);
  3784. }
  3785. } while (h == 0);
  3786. if (h > 0) {
  3787. if (get_net_conf(tconn)) {
  3788. drbdd(tconn);
  3789. put_net_conf(tconn);
  3790. }
  3791. }
  3792. drbd_disconnect(tconn);
  3793. conn_info(tconn, "receiver terminated\n");
  3794. return 0;
  3795. }
  3796. /* ********* acknowledge sender ******** */
  3797. static int got_conn_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi)
  3798. {
  3799. struct p_req_state_reply *p = tconn->meta.rbuf;
  3800. int retcode = be32_to_cpu(p->retcode);
  3801. if (retcode >= SS_SUCCESS) {
  3802. set_bit(CONN_WD_ST_CHG_OKAY, &tconn->flags);
  3803. } else {
  3804. set_bit(CONN_WD_ST_CHG_FAIL, &tconn->flags);
  3805. conn_err(tconn, "Requested state change failed by peer: %s (%d)\n",
  3806. drbd_set_st_err_str(retcode), retcode);
  3807. }
  3808. wake_up(&tconn->ping_wait);
  3809. return true;
  3810. }
  3811. static int got_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi)
  3812. {
  3813. struct drbd_conf *mdev;
  3814. struct p_req_state_reply *p = tconn->meta.rbuf;
  3815. int retcode = be32_to_cpu(p->retcode);
  3816. mdev = vnr_to_mdev(tconn, pi->vnr);
  3817. if (!mdev)
  3818. return false;
  3819. if (retcode >= SS_SUCCESS) {
  3820. set_bit(CL_ST_CHG_SUCCESS, &mdev->flags);
  3821. } else {
  3822. set_bit(CL_ST_CHG_FAIL, &mdev->flags);
  3823. dev_err(DEV, "Requested state change failed by peer: %s (%d)\n",
  3824. drbd_set_st_err_str(retcode), retcode);
  3825. }
  3826. wake_up(&mdev->state_wait);
  3827. return true;
  3828. }
  3829. static int got_Ping(struct drbd_tconn *tconn, struct packet_info *pi)
  3830. {
  3831. return drbd_send_ping_ack(tconn);
  3832. }
  3833. static int got_PingAck(struct drbd_tconn *tconn, struct packet_info *pi)
  3834. {
  3835. /* restore idle timeout */
  3836. tconn->meta.socket->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ;
  3837. if (!test_and_set_bit(GOT_PING_ACK, &tconn->flags))
  3838. wake_up(&tconn->ping_wait);
  3839. return true;
  3840. }
  3841. static int got_IsInSync(struct drbd_tconn *tconn, struct packet_info *pi)
  3842. {
  3843. struct drbd_conf *mdev;
  3844. struct p_block_ack *p = tconn->meta.rbuf;
  3845. sector_t sector = be64_to_cpu(p->sector);
  3846. int blksize = be32_to_cpu(p->blksize);
  3847. mdev = vnr_to_mdev(tconn, pi->vnr);
  3848. if (!mdev)
  3849. return false;
  3850. D_ASSERT(mdev->tconn->agreed_pro_version >= 89);
  3851. update_peer_seq(mdev, be32_to_cpu(p->seq_num));
  3852. if (get_ldev(mdev)) {
  3853. drbd_rs_complete_io(mdev, sector);
  3854. drbd_set_in_sync(mdev, sector, blksize);
  3855. /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */
  3856. mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT);
  3857. put_ldev(mdev);
  3858. }
  3859. dec_rs_pending(mdev);
  3860. atomic_add(blksize >> 9, &mdev->rs_sect_in);
  3861. return true;
  3862. }
  3863. static int
  3864. validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector,
  3865. struct rb_root *root, const char *func,
  3866. enum drbd_req_event what, bool missing_ok)
  3867. {
  3868. struct drbd_request *req;
  3869. struct bio_and_error m;
  3870. spin_lock_irq(&mdev->tconn->req_lock);
  3871. req = find_request(mdev, root, id, sector, missing_ok, func);
  3872. if (unlikely(!req)) {
  3873. spin_unlock_irq(&mdev->tconn->req_lock);
  3874. return false;
  3875. }
  3876. __req_mod(req, what, &m);
  3877. spin_unlock_irq(&mdev->tconn->req_lock);
  3878. if (m.bio)
  3879. complete_master_bio(mdev, &m);
  3880. return true;
  3881. }
  3882. static int got_BlockAck(struct drbd_tconn *tconn, struct packet_info *pi)
  3883. {
  3884. struct drbd_conf *mdev;
  3885. struct p_block_ack *p = tconn->meta.rbuf;
  3886. sector_t sector = be64_to_cpu(p->sector);
  3887. int blksize = be32_to_cpu(p->blksize);
  3888. enum drbd_req_event what;
  3889. mdev = vnr_to_mdev(tconn, pi->vnr);
  3890. if (!mdev)
  3891. return false;
  3892. update_peer_seq(mdev, be32_to_cpu(p->seq_num));
  3893. if (p->block_id == ID_SYNCER) {
  3894. drbd_set_in_sync(mdev, sector, blksize);
  3895. dec_rs_pending(mdev);
  3896. return true;
  3897. }
  3898. switch (pi->cmd) {
  3899. case P_RS_WRITE_ACK:
  3900. D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C);
  3901. what = WRITE_ACKED_BY_PEER_AND_SIS;
  3902. break;
  3903. case P_WRITE_ACK:
  3904. D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C);
  3905. what = WRITE_ACKED_BY_PEER;
  3906. break;
  3907. case P_RECV_ACK:
  3908. D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_B);
  3909. what = RECV_ACKED_BY_PEER;
  3910. break;
  3911. case P_DISCARD_WRITE:
  3912. D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C);
  3913. what = DISCARD_WRITE;
  3914. break;
  3915. case P_RETRY_WRITE:
  3916. D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C);
  3917. what = POSTPONE_WRITE;
  3918. break;
  3919. default:
  3920. D_ASSERT(0);
  3921. return false;
  3922. }
  3923. return validate_req_change_req_state(mdev, p->block_id, sector,
  3924. &mdev->write_requests, __func__,
  3925. what, false);
  3926. }
  3927. static int got_NegAck(struct drbd_tconn *tconn, struct packet_info *pi)
  3928. {
  3929. struct drbd_conf *mdev;
  3930. struct p_block_ack *p = tconn->meta.rbuf;
  3931. sector_t sector = be64_to_cpu(p->sector);
  3932. int size = be32_to_cpu(p->blksize);
  3933. bool missing_ok = tconn->net_conf->wire_protocol == DRBD_PROT_A ||
  3934. tconn->net_conf->wire_protocol == DRBD_PROT_B;
  3935. bool found;
  3936. mdev = vnr_to_mdev(tconn, pi->vnr);
  3937. if (!mdev)
  3938. return false;
  3939. update_peer_seq(mdev, be32_to_cpu(p->seq_num));
  3940. if (p->block_id == ID_SYNCER) {
  3941. dec_rs_pending(mdev);
  3942. drbd_rs_failed_io(mdev, sector, size);
  3943. return true;
  3944. }
  3945. found = validate_req_change_req_state(mdev, p->block_id, sector,
  3946. &mdev->write_requests, __func__,
  3947. NEG_ACKED, missing_ok);
  3948. if (!found) {
  3949. /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs.
  3950. The master bio might already be completed, therefore the
  3951. request is no longer in the collision hash. */
  3952. /* In Protocol B we might already have got a P_RECV_ACK
  3953. but then get a P_NEG_ACK afterwards. */
  3954. if (!missing_ok)
  3955. return false;
  3956. drbd_set_out_of_sync(mdev, sector, size);
  3957. }
  3958. return true;
  3959. }
  3960. static int got_NegDReply(struct drbd_tconn *tconn, struct packet_info *pi)
  3961. {
  3962. struct drbd_conf *mdev;
  3963. struct p_block_ack *p = tconn->meta.rbuf;
  3964. sector_t sector = be64_to_cpu(p->sector);
  3965. mdev = vnr_to_mdev(tconn, pi->vnr);
  3966. if (!mdev)
  3967. return false;
  3968. update_peer_seq(mdev, be32_to_cpu(p->seq_num));
  3969. dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n",
  3970. (unsigned long long)sector, be32_to_cpu(p->blksize));
  3971. return validate_req_change_req_state(mdev, p->block_id, sector,
  3972. &mdev->read_requests, __func__,
  3973. NEG_ACKED, false);
  3974. }
  3975. static int got_NegRSDReply(struct drbd_tconn *tconn, struct packet_info *pi)
  3976. {
  3977. struct drbd_conf *mdev;
  3978. sector_t sector;
  3979. int size;
  3980. struct p_block_ack *p = tconn->meta.rbuf;
  3981. mdev = vnr_to_mdev(tconn, pi->vnr);
  3982. if (!mdev)
  3983. return false;
  3984. sector = be64_to_cpu(p->sector);
  3985. size = be32_to_cpu(p->blksize);
  3986. update_peer_seq(mdev, be32_to_cpu(p->seq_num));
  3987. dec_rs_pending(mdev);
  3988. if (get_ldev_if_state(mdev, D_FAILED)) {
  3989. drbd_rs_complete_io(mdev, sector);
  3990. switch (pi->cmd) {
  3991. case P_NEG_RS_DREPLY:
  3992. drbd_rs_failed_io(mdev, sector, size);
  3993. case P_RS_CANCEL:
  3994. break;
  3995. default:
  3996. D_ASSERT(0);
  3997. put_ldev(mdev);
  3998. return false;
  3999. }
  4000. put_ldev(mdev);
  4001. }
  4002. return true;
  4003. }
  4004. static int got_BarrierAck(struct drbd_tconn *tconn, struct packet_info *pi)
  4005. {
  4006. struct drbd_conf *mdev;
  4007. struct p_barrier_ack *p = tconn->meta.rbuf;
  4008. mdev = vnr_to_mdev(tconn, pi->vnr);
  4009. if (!mdev)
  4010. return false;
  4011. tl_release(mdev->tconn, p->barrier, be32_to_cpu(p->set_size));
  4012. if (mdev->state.conn == C_AHEAD &&
  4013. atomic_read(&mdev->ap_in_flight) == 0 &&
  4014. !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->current_epoch->flags)) {
  4015. mdev->start_resync_timer.expires = jiffies + HZ;
  4016. add_timer(&mdev->start_resync_timer);
  4017. }
  4018. return true;
  4019. }
  4020. static int got_OVResult(struct drbd_tconn *tconn, struct packet_info *pi)
  4021. {
  4022. struct drbd_conf *mdev;
  4023. struct p_block_ack *p = tconn->meta.rbuf;
  4024. struct drbd_work *w;
  4025. sector_t sector;
  4026. int size;
  4027. mdev = vnr_to_mdev(tconn, pi->vnr);
  4028. if (!mdev)
  4029. return false;
  4030. sector = be64_to_cpu(p->sector);
  4031. size = be32_to_cpu(p->blksize);
  4032. update_peer_seq(mdev, be32_to_cpu(p->seq_num));
  4033. if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC)
  4034. drbd_ov_out_of_sync_found(mdev, sector, size);
  4035. else
  4036. ov_out_of_sync_print(mdev);
  4037. if (!get_ldev(mdev))
  4038. return true;
  4039. drbd_rs_complete_io(mdev, sector);
  4040. dec_rs_pending(mdev);
  4041. --mdev->ov_left;
  4042. /* let's advance progress step marks only for every other megabyte */
  4043. if ((mdev->ov_left & 0x200) == 0x200)
  4044. drbd_advance_rs_marks(mdev, mdev->ov_left);
  4045. if (mdev->ov_left == 0) {
  4046. w = kmalloc(sizeof(*w), GFP_NOIO);
  4047. if (w) {
  4048. w->cb = w_ov_finished;
  4049. w->mdev = mdev;
  4050. drbd_queue_work_front(&mdev->tconn->data.work, w);
  4051. } else {
  4052. dev_err(DEV, "kmalloc(w) failed.");
  4053. ov_out_of_sync_print(mdev);
  4054. drbd_resync_finished(mdev);
  4055. }
  4056. }
  4057. put_ldev(mdev);
  4058. return true;
  4059. }
  4060. static int got_skip(struct drbd_tconn *tconn, struct packet_info *pi)
  4061. {
  4062. return true;
  4063. }
  4064. static int tconn_process_done_ee(struct drbd_tconn *tconn)
  4065. {
  4066. struct drbd_conf *mdev;
  4067. int i, not_empty = 0;
  4068. do {
  4069. clear_bit(SIGNAL_ASENDER, &tconn->flags);
  4070. flush_signals(current);
  4071. idr_for_each_entry(&tconn->volumes, mdev, i) {
  4072. if (drbd_process_done_ee(mdev))
  4073. return 1; /* error */
  4074. }
  4075. set_bit(SIGNAL_ASENDER, &tconn->flags);
  4076. spin_lock_irq(&tconn->req_lock);
  4077. idr_for_each_entry(&tconn->volumes, mdev, i) {
  4078. not_empty = !list_empty(&mdev->done_ee);
  4079. if (not_empty)
  4080. break;
  4081. }
  4082. spin_unlock_irq(&tconn->req_lock);
  4083. } while (not_empty);
  4084. return 0;
  4085. }
  4086. struct asender_cmd {
  4087. size_t pkt_size;
  4088. int (*fn)(struct drbd_tconn *tconn, struct packet_info *);
  4089. };
  4090. static struct asender_cmd asender_tbl[] = {
  4091. [P_PING] = { sizeof(struct p_header), got_Ping },
  4092. [P_PING_ACK] = { sizeof(struct p_header), got_PingAck },
  4093. [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck },
  4094. [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck },
  4095. [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck },
  4096. [P_DISCARD_WRITE] = { sizeof(struct p_block_ack), got_BlockAck },
  4097. [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck },
  4098. [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply },
  4099. [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply },
  4100. [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult },
  4101. [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck },
  4102. [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply },
  4103. [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync },
  4104. [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip },
  4105. [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply },
  4106. [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply },
  4107. [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck },
  4108. };
  4109. int drbd_asender(struct drbd_thread *thi)
  4110. {
  4111. struct drbd_tconn *tconn = thi->tconn;
  4112. struct p_header *h = tconn->meta.rbuf;
  4113. struct asender_cmd *cmd = NULL;
  4114. struct packet_info pi;
  4115. int rv;
  4116. void *buf = h;
  4117. int received = 0;
  4118. int expect = sizeof(struct p_header);
  4119. int ping_timeout_active = 0;
  4120. current->policy = SCHED_RR; /* Make this a realtime task! */
  4121. current->rt_priority = 2; /* more important than all other tasks */
  4122. while (get_t_state(thi) == RUNNING) {
  4123. drbd_thread_current_set_cpu(thi);
  4124. if (test_and_clear_bit(SEND_PING, &tconn->flags)) {
  4125. if (!drbd_send_ping(tconn)) {
  4126. conn_err(tconn, "drbd_send_ping has failed\n");
  4127. goto reconnect;
  4128. }
  4129. tconn->meta.socket->sk->sk_rcvtimeo =
  4130. tconn->net_conf->ping_timeo*HZ/10;
  4131. ping_timeout_active = 1;
  4132. }
  4133. /* TODO: conditionally cork; it may hurt latency if we cork without
  4134. much to send */
  4135. if (!tconn->net_conf->no_cork)
  4136. drbd_tcp_cork(tconn->meta.socket);
  4137. if (tconn_process_done_ee(tconn)) {
  4138. conn_err(tconn, "tconn_process_done_ee() failed\n");
  4139. goto reconnect;
  4140. }
  4141. /* but unconditionally uncork unless disabled */
  4142. if (!tconn->net_conf->no_cork)
  4143. drbd_tcp_uncork(tconn->meta.socket);
  4144. /* short circuit, recv_msg would return EINTR anyways. */
  4145. if (signal_pending(current))
  4146. continue;
  4147. rv = drbd_recv_short(tconn->meta.socket, buf, expect-received, 0);
  4148. clear_bit(SIGNAL_ASENDER, &tconn->flags);
  4149. flush_signals(current);
  4150. /* Note:
  4151. * -EINTR (on meta) we got a signal
  4152. * -EAGAIN (on meta) rcvtimeo expired
  4153. * -ECONNRESET other side closed the connection
  4154. * -ERESTARTSYS (on data) we got a signal
  4155. * rv < 0 other than above: unexpected error!
  4156. * rv == expected: full header or command
  4157. * rv < expected: "woken" by signal during receive
  4158. * rv == 0 : "connection shut down by peer"
  4159. */
  4160. if (likely(rv > 0)) {
  4161. received += rv;
  4162. buf += rv;
  4163. } else if (rv == 0) {
  4164. conn_err(tconn, "meta connection shut down by peer.\n");
  4165. goto reconnect;
  4166. } else if (rv == -EAGAIN) {
  4167. /* If the data socket received something meanwhile,
  4168. * that is good enough: peer is still alive. */
  4169. if (time_after(tconn->last_received,
  4170. jiffies - tconn->meta.socket->sk->sk_rcvtimeo))
  4171. continue;
  4172. if (ping_timeout_active) {
  4173. conn_err(tconn, "PingAck did not arrive in time.\n");
  4174. goto reconnect;
  4175. }
  4176. set_bit(SEND_PING, &tconn->flags);
  4177. continue;
  4178. } else if (rv == -EINTR) {
  4179. continue;
  4180. } else {
  4181. conn_err(tconn, "sock_recvmsg returned %d\n", rv);
  4182. goto reconnect;
  4183. }
  4184. if (received == expect && cmd == NULL) {
  4185. if (decode_header(tconn, h, &pi))
  4186. goto reconnect;
  4187. cmd = &asender_tbl[pi.cmd];
  4188. if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd->fn) {
  4189. conn_err(tconn, "unknown command %d on meta (l: %d)\n",
  4190. pi.cmd, pi.size);
  4191. goto disconnect;
  4192. }
  4193. expect = cmd->pkt_size;
  4194. if (pi.size != expect - sizeof(struct p_header)) {
  4195. conn_err(tconn, "Wrong packet size on meta (c: %d, l: %d)\n",
  4196. pi.cmd, pi.size);
  4197. goto reconnect;
  4198. }
  4199. }
  4200. if (received == expect) {
  4201. bool rv;
  4202. rv = cmd->fn(tconn, &pi);
  4203. if (!rv) {
  4204. conn_err(tconn, "%pf failed\n", cmd->fn);
  4205. goto reconnect;
  4206. }
  4207. tconn->last_received = jiffies;
  4208. /* the idle_timeout (ping-int)
  4209. * has been restored in got_PingAck() */
  4210. if (cmd == &asender_tbl[P_PING_ACK])
  4211. ping_timeout_active = 0;
  4212. buf = h;
  4213. received = 0;
  4214. expect = sizeof(struct p_header);
  4215. cmd = NULL;
  4216. }
  4217. }
  4218. if (0) {
  4219. reconnect:
  4220. conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD);
  4221. }
  4222. if (0) {
  4223. disconnect:
  4224. conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD);
  4225. }
  4226. clear_bit(SIGNAL_ASENDER, &tconn->flags);
  4227. conn_info(tconn, "asender terminated\n");
  4228. return 0;
  4229. }