nfs4proc.c 187 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359436043614362436343644365436643674368436943704371437243734374437543764377437843794380438143824383438443854386438743884389439043914392439343944395439643974398439944004401440244034404440544064407440844094410441144124413441444154416441744184419442044214422442344244425442644274428442944304431443244334434443544364437443844394440444144424443444444454446444744484449445044514452445344544455445644574458445944604461446244634464446544664467446844694470447144724473447444754476447744784479448044814482448344844485448644874488448944904491449244934494449544964497449844994500450145024503450445054506450745084509451045114512451345144515451645174518451945204521452245234524452545264527452845294530453145324533453445354536453745384539454045414542454345444545454645474548454945504551455245534554455545564557455845594560456145624563456445654566456745684569457045714572457345744575457645774578457945804581458245834584458545864587458845894590459145924593459445954596459745984599460046014602460346044605460646074608460946104611461246134614461546164617461846194620462146224623462446254626462746284629463046314632463346344635463646374638463946404641464246434644464546464647464846494650465146524653465446554656465746584659466046614662466346644665466646674668466946704671467246734674467546764677467846794680468146824683468446854686468746884689469046914692469346944695469646974698469947004701470247034704470547064707470847094710471147124713471447154716471747184719472047214722472347244725472647274728472947304731473247334734473547364737473847394740474147424743474447454746474747484749475047514752475347544755475647574758475947604761476247634764476547664767476847694770477147724773477447754776477747784779478047814782478347844785478647874788478947904791479247934794479547964797479847994800480148024803480448054806480748084809481048114812481348144815481648174818481948204821482248234824482548264827482848294830483148324833483448354836483748384839484048414842484348444845484648474848484948504851485248534854485548564857485848594860486148624863486448654866486748684869487048714872487348744875487648774878487948804881488248834884488548864887488848894890489148924893489448954896489748984899490049014902490349044905490649074908490949104911491249134914491549164917491849194920492149224923492449254926492749284929493049314932493349344935493649374938493949404941494249434944494549464947494849494950495149524953495449554956495749584959496049614962496349644965496649674968496949704971497249734974497549764977497849794980498149824983498449854986498749884989499049914992499349944995499649974998499950005001500250035004500550065007500850095010501150125013501450155016501750185019502050215022502350245025502650275028502950305031503250335034503550365037503850395040504150425043504450455046504750485049505050515052505350545055505650575058505950605061506250635064506550665067506850695070507150725073507450755076507750785079508050815082508350845085508650875088508950905091509250935094509550965097509850995100510151025103510451055106510751085109511051115112511351145115511651175118511951205121512251235124512551265127512851295130513151325133513451355136513751385139514051415142514351445145514651475148514951505151515251535154515551565157515851595160516151625163516451655166516751685169517051715172517351745175517651775178517951805181518251835184518551865187518851895190519151925193519451955196519751985199520052015202520352045205520652075208520952105211521252135214521552165217521852195220522152225223522452255226522752285229523052315232523352345235523652375238523952405241524252435244524552465247524852495250525152525253525452555256525752585259526052615262526352645265526652675268526952705271527252735274527552765277527852795280528152825283528452855286528752885289529052915292529352945295529652975298529953005301530253035304530553065307530853095310531153125313531453155316531753185319532053215322532353245325532653275328532953305331533253335334533553365337533853395340534153425343534453455346534753485349535053515352535353545355535653575358535953605361536253635364536553665367536853695370537153725373537453755376537753785379538053815382538353845385538653875388538953905391539253935394539553965397539853995400540154025403540454055406540754085409541054115412541354145415541654175418541954205421542254235424542554265427542854295430543154325433543454355436543754385439544054415442544354445445544654475448544954505451545254535454545554565457545854595460546154625463546454655466546754685469547054715472547354745475547654775478547954805481548254835484548554865487548854895490549154925493549454955496549754985499550055015502550355045505550655075508550955105511551255135514551555165517551855195520552155225523552455255526552755285529553055315532553355345535553655375538553955405541554255435544554555465547554855495550555155525553555455555556555755585559556055615562556355645565556655675568556955705571557255735574557555765577557855795580558155825583558455855586558755885589559055915592559355945595559655975598559956005601560256035604560556065607560856095610561156125613561456155616561756185619562056215622562356245625562656275628562956305631563256335634563556365637563856395640564156425643564456455646564756485649565056515652565356545655565656575658565956605661566256635664566556665667566856695670567156725673567456755676567756785679568056815682568356845685568656875688568956905691569256935694569556965697569856995700570157025703570457055706570757085709571057115712571357145715571657175718571957205721572257235724572557265727572857295730573157325733573457355736573757385739574057415742574357445745574657475748574957505751575257535754575557565757575857595760576157625763576457655766576757685769577057715772577357745775577657775778577957805781578257835784578557865787578857895790579157925793579457955796579757985799580058015802580358045805580658075808580958105811581258135814581558165817581858195820582158225823582458255826582758285829583058315832583358345835583658375838583958405841584258435844584558465847584858495850585158525853585458555856585758585859586058615862586358645865586658675868586958705871587258735874587558765877587858795880588158825883588458855886588758885889589058915892589358945895589658975898589959005901590259035904590559065907590859095910591159125913591459155916591759185919592059215922592359245925592659275928592959305931593259335934593559365937593859395940594159425943594459455946594759485949595059515952595359545955595659575958595959605961596259635964596559665967596859695970597159725973597459755976597759785979598059815982598359845985598659875988598959905991599259935994599559965997599859996000600160026003600460056006600760086009601060116012601360146015601660176018601960206021602260236024602560266027602860296030603160326033603460356036603760386039604060416042604360446045604660476048604960506051605260536054605560566057605860596060606160626063606460656066606760686069607060716072607360746075607660776078607960806081608260836084608560866087608860896090609160926093609460956096609760986099610061016102610361046105610661076108610961106111611261136114611561166117611861196120612161226123612461256126612761286129613061316132613361346135613661376138613961406141614261436144614561466147614861496150615161526153615461556156615761586159616061616162616361646165616661676168616961706171617261736174617561766177617861796180618161826183618461856186618761886189619061916192619361946195619661976198619962006201620262036204620562066207620862096210621162126213621462156216621762186219622062216222622362246225622662276228622962306231623262336234623562366237623862396240624162426243624462456246624762486249625062516252625362546255625662576258625962606261626262636264626562666267626862696270627162726273627462756276627762786279628062816282628362846285628662876288628962906291629262936294629562966297629862996300630163026303630463056306630763086309631063116312631363146315631663176318631963206321632263236324632563266327632863296330633163326333633463356336633763386339634063416342634363446345634663476348634963506351635263536354635563566357635863596360636163626363636463656366636763686369637063716372637363746375637663776378637963806381638263836384638563866387638863896390639163926393639463956396639763986399640064016402640364046405640664076408640964106411641264136414641564166417641864196420642164226423642464256426642764286429643064316432643364346435643664376438643964406441644264436444644564466447644864496450645164526453645464556456645764586459646064616462646364646465646664676468646964706471647264736474647564766477647864796480648164826483648464856486648764886489649064916492649364946495649664976498649965006501650265036504650565066507650865096510651165126513651465156516651765186519652065216522652365246525652665276528652965306531653265336534653565366537653865396540654165426543654465456546654765486549655065516552655365546555655665576558655965606561656265636564656565666567656865696570657165726573657465756576657765786579658065816582658365846585658665876588658965906591659265936594659565966597659865996600660166026603660466056606660766086609661066116612661366146615661666176618661966206621662266236624662566266627662866296630663166326633663466356636663766386639664066416642664366446645664666476648664966506651665266536654665566566657665866596660666166626663666466656666666766686669667066716672667366746675667666776678667966806681668266836684668566866687668866896690669166926693669466956696669766986699670067016702670367046705670667076708670967106711671267136714671567166717671867196720672167226723672467256726672767286729673067316732673367346735673667376738673967406741674267436744674567466747674867496750675167526753675467556756675767586759676067616762676367646765676667676768676967706771677267736774677567766777677867796780678167826783678467856786678767886789679067916792679367946795679667976798679968006801680268036804680568066807680868096810681168126813681468156816681768186819682068216822682368246825682668276828682968306831683268336834683568366837683868396840684168426843684468456846684768486849685068516852685368546855685668576858685968606861686268636864686568666867686868696870687168726873687468756876687768786879688068816882688368846885688668876888688968906891689268936894689568966897689868996900690169026903690469056906690769086909691069116912691369146915691669176918691969206921692269236924692569266927692869296930693169326933693469356936693769386939694069416942694369446945694669476948694969506951695269536954695569566957695869596960696169626963696469656966696769686969697069716972697369746975697669776978697969806981698269836984698569866987698869896990699169926993699469956996699769986999700070017002700370047005700670077008700970107011701270137014
  1. /*
  2. * fs/nfs/nfs4proc.c
  3. *
  4. * Client-side procedure declarations for NFSv4.
  5. *
  6. * Copyright (c) 2002 The Regents of the University of Michigan.
  7. * All rights reserved.
  8. *
  9. * Kendrick Smith <kmsmith@umich.edu>
  10. * Andy Adamson <andros@umich.edu>
  11. *
  12. * Redistribution and use in source and binary forms, with or without
  13. * modification, are permitted provided that the following conditions
  14. * are met:
  15. *
  16. * 1. Redistributions of source code must retain the above copyright
  17. * notice, this list of conditions and the following disclaimer.
  18. * 2. Redistributions in binary form must reproduce the above copyright
  19. * notice, this list of conditions and the following disclaimer in the
  20. * documentation and/or other materials provided with the distribution.
  21. * 3. Neither the name of the University nor the names of its
  22. * contributors may be used to endorse or promote products derived
  23. * from this software without specific prior written permission.
  24. *
  25. * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  26. * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  27. * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  28. * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  30. * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  31. * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  32. * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  33. * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  34. * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  35. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36. */
  37. #include <linux/mm.h>
  38. #include <linux/delay.h>
  39. #include <linux/errno.h>
  40. #include <linux/string.h>
  41. #include <linux/ratelimit.h>
  42. #include <linux/printk.h>
  43. #include <linux/slab.h>
  44. #include <linux/sunrpc/clnt.h>
  45. #include <linux/nfs.h>
  46. #include <linux/nfs4.h>
  47. #include <linux/nfs_fs.h>
  48. #include <linux/nfs_page.h>
  49. #include <linux/nfs_mount.h>
  50. #include <linux/namei.h>
  51. #include <linux/mount.h>
  52. #include <linux/module.h>
  53. #include <linux/nfs_idmap.h>
  54. #include <linux/xattr.h>
  55. #include <linux/utsname.h>
  56. #include <linux/freezer.h>
  57. #include "nfs4_fs.h"
  58. #include "delegation.h"
  59. #include "internal.h"
  60. #include "iostat.h"
  61. #include "callback.h"
  62. #include "pnfs.h"
  63. #include "netns.h"
  64. #include "nfs4session.h"
  65. #include "fscache.h"
  66. #define NFSDBG_FACILITY NFSDBG_PROC
  67. #define NFS4_POLL_RETRY_MIN (HZ/10)
  68. #define NFS4_POLL_RETRY_MAX (15*HZ)
  69. struct nfs4_opendata;
  70. static int _nfs4_proc_open(struct nfs4_opendata *data);
  71. static int _nfs4_recover_proc_open(struct nfs4_opendata *data);
  72. static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *);
  73. static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *, struct nfs4_state *);
  74. static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr);
  75. static int nfs4_proc_getattr(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *);
  76. static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr);
  77. static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
  78. struct nfs_fattr *fattr, struct iattr *sattr,
  79. struct nfs4_state *state);
  80. #ifdef CONFIG_NFS_V4_1
  81. static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *);
  82. static int nfs41_free_stateid(struct nfs_server *, nfs4_stateid *);
  83. #endif
  84. /* Prevent leaks of NFSv4 errors into userland */
  85. static int nfs4_map_errors(int err)
  86. {
  87. if (err >= -1000)
  88. return err;
  89. switch (err) {
  90. case -NFS4ERR_RESOURCE:
  91. case -NFS4ERR_LAYOUTTRYLATER:
  92. case -NFS4ERR_RECALLCONFLICT:
  93. return -EREMOTEIO;
  94. case -NFS4ERR_WRONGSEC:
  95. return -EPERM;
  96. case -NFS4ERR_BADOWNER:
  97. case -NFS4ERR_BADNAME:
  98. return -EINVAL;
  99. case -NFS4ERR_SHARE_DENIED:
  100. return -EACCES;
  101. case -NFS4ERR_MINOR_VERS_MISMATCH:
  102. return -EPROTONOSUPPORT;
  103. case -NFS4ERR_ACCESS:
  104. return -EACCES;
  105. case -NFS4ERR_FILE_OPEN:
  106. return -EBUSY;
  107. default:
  108. dprintk("%s could not handle NFSv4 error %d\n",
  109. __func__, -err);
  110. break;
  111. }
  112. return -EIO;
  113. }
  114. /*
  115. * This is our standard bitmap for GETATTR requests.
  116. */
  117. const u32 nfs4_fattr_bitmap[3] = {
  118. FATTR4_WORD0_TYPE
  119. | FATTR4_WORD0_CHANGE
  120. | FATTR4_WORD0_SIZE
  121. | FATTR4_WORD0_FSID
  122. | FATTR4_WORD0_FILEID,
  123. FATTR4_WORD1_MODE
  124. | FATTR4_WORD1_NUMLINKS
  125. | FATTR4_WORD1_OWNER
  126. | FATTR4_WORD1_OWNER_GROUP
  127. | FATTR4_WORD1_RAWDEV
  128. | FATTR4_WORD1_SPACE_USED
  129. | FATTR4_WORD1_TIME_ACCESS
  130. | FATTR4_WORD1_TIME_METADATA
  131. | FATTR4_WORD1_TIME_MODIFY
  132. };
  133. static const u32 nfs4_pnfs_open_bitmap[3] = {
  134. FATTR4_WORD0_TYPE
  135. | FATTR4_WORD0_CHANGE
  136. | FATTR4_WORD0_SIZE
  137. | FATTR4_WORD0_FSID
  138. | FATTR4_WORD0_FILEID,
  139. FATTR4_WORD1_MODE
  140. | FATTR4_WORD1_NUMLINKS
  141. | FATTR4_WORD1_OWNER
  142. | FATTR4_WORD1_OWNER_GROUP
  143. | FATTR4_WORD1_RAWDEV
  144. | FATTR4_WORD1_SPACE_USED
  145. | FATTR4_WORD1_TIME_ACCESS
  146. | FATTR4_WORD1_TIME_METADATA
  147. | FATTR4_WORD1_TIME_MODIFY,
  148. FATTR4_WORD2_MDSTHRESHOLD
  149. };
  150. static const u32 nfs4_open_noattr_bitmap[3] = {
  151. FATTR4_WORD0_TYPE
  152. | FATTR4_WORD0_CHANGE
  153. | FATTR4_WORD0_FILEID,
  154. };
  155. const u32 nfs4_statfs_bitmap[2] = {
  156. FATTR4_WORD0_FILES_AVAIL
  157. | FATTR4_WORD0_FILES_FREE
  158. | FATTR4_WORD0_FILES_TOTAL,
  159. FATTR4_WORD1_SPACE_AVAIL
  160. | FATTR4_WORD1_SPACE_FREE
  161. | FATTR4_WORD1_SPACE_TOTAL
  162. };
  163. const u32 nfs4_pathconf_bitmap[2] = {
  164. FATTR4_WORD0_MAXLINK
  165. | FATTR4_WORD0_MAXNAME,
  166. 0
  167. };
  168. const u32 nfs4_fsinfo_bitmap[3] = { FATTR4_WORD0_MAXFILESIZE
  169. | FATTR4_WORD0_MAXREAD
  170. | FATTR4_WORD0_MAXWRITE
  171. | FATTR4_WORD0_LEASE_TIME,
  172. FATTR4_WORD1_TIME_DELTA
  173. | FATTR4_WORD1_FS_LAYOUT_TYPES,
  174. FATTR4_WORD2_LAYOUT_BLKSIZE
  175. };
  176. const u32 nfs4_fs_locations_bitmap[2] = {
  177. FATTR4_WORD0_TYPE
  178. | FATTR4_WORD0_CHANGE
  179. | FATTR4_WORD0_SIZE
  180. | FATTR4_WORD0_FSID
  181. | FATTR4_WORD0_FILEID
  182. | FATTR4_WORD0_FS_LOCATIONS,
  183. FATTR4_WORD1_MODE
  184. | FATTR4_WORD1_NUMLINKS
  185. | FATTR4_WORD1_OWNER
  186. | FATTR4_WORD1_OWNER_GROUP
  187. | FATTR4_WORD1_RAWDEV
  188. | FATTR4_WORD1_SPACE_USED
  189. | FATTR4_WORD1_TIME_ACCESS
  190. | FATTR4_WORD1_TIME_METADATA
  191. | FATTR4_WORD1_TIME_MODIFY
  192. | FATTR4_WORD1_MOUNTED_ON_FILEID
  193. };
  194. static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry,
  195. struct nfs4_readdir_arg *readdir)
  196. {
  197. __be32 *start, *p;
  198. if (cookie > 2) {
  199. readdir->cookie = cookie;
  200. memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier));
  201. return;
  202. }
  203. readdir->cookie = 0;
  204. memset(&readdir->verifier, 0, sizeof(readdir->verifier));
  205. if (cookie == 2)
  206. return;
  207. /*
  208. * NFSv4 servers do not return entries for '.' and '..'
  209. * Therefore, we fake these entries here. We let '.'
  210. * have cookie 0 and '..' have cookie 1. Note that
  211. * when talking to the server, we always send cookie 0
  212. * instead of 1 or 2.
  213. */
  214. start = p = kmap_atomic(*readdir->pages);
  215. if (cookie == 0) {
  216. *p++ = xdr_one; /* next */
  217. *p++ = xdr_zero; /* cookie, first word */
  218. *p++ = xdr_one; /* cookie, second word */
  219. *p++ = xdr_one; /* entry len */
  220. memcpy(p, ".\0\0\0", 4); /* entry */
  221. p++;
  222. *p++ = xdr_one; /* bitmap length */
  223. *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */
  224. *p++ = htonl(8); /* attribute buffer length */
  225. p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode));
  226. }
  227. *p++ = xdr_one; /* next */
  228. *p++ = xdr_zero; /* cookie, first word */
  229. *p++ = xdr_two; /* cookie, second word */
  230. *p++ = xdr_two; /* entry len */
  231. memcpy(p, "..\0\0", 4); /* entry */
  232. p++;
  233. *p++ = xdr_one; /* bitmap length */
  234. *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */
  235. *p++ = htonl(8); /* attribute buffer length */
  236. p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode));
  237. readdir->pgbase = (char *)p - (char *)start;
  238. readdir->count -= readdir->pgbase;
  239. kunmap_atomic(start);
  240. }
  241. static int nfs4_delay(struct rpc_clnt *clnt, long *timeout)
  242. {
  243. int res = 0;
  244. might_sleep();
  245. if (*timeout <= 0)
  246. *timeout = NFS4_POLL_RETRY_MIN;
  247. if (*timeout > NFS4_POLL_RETRY_MAX)
  248. *timeout = NFS4_POLL_RETRY_MAX;
  249. freezable_schedule_timeout_killable(*timeout);
  250. if (fatal_signal_pending(current))
  251. res = -ERESTARTSYS;
  252. *timeout <<= 1;
  253. return res;
  254. }
  255. /* This is the error handling routine for processes that are allowed
  256. * to sleep.
  257. */
  258. static int nfs4_handle_exception(struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
  259. {
  260. struct nfs_client *clp = server->nfs_client;
  261. struct nfs4_state *state = exception->state;
  262. struct inode *inode = exception->inode;
  263. int ret = errorcode;
  264. exception->retry = 0;
  265. switch(errorcode) {
  266. case 0:
  267. return 0;
  268. case -NFS4ERR_OPENMODE:
  269. if (inode && nfs4_have_delegation(inode, FMODE_READ)) {
  270. nfs4_inode_return_delegation(inode);
  271. exception->retry = 1;
  272. return 0;
  273. }
  274. if (state == NULL)
  275. break;
  276. ret = nfs4_schedule_stateid_recovery(server, state);
  277. if (ret < 0)
  278. break;
  279. goto wait_on_recovery;
  280. case -NFS4ERR_DELEG_REVOKED:
  281. case -NFS4ERR_ADMIN_REVOKED:
  282. case -NFS4ERR_BAD_STATEID:
  283. if (inode != NULL && nfs4_have_delegation(inode, FMODE_READ)) {
  284. nfs_remove_bad_delegation(inode);
  285. exception->retry = 1;
  286. break;
  287. }
  288. if (state == NULL)
  289. break;
  290. ret = nfs4_schedule_stateid_recovery(server, state);
  291. if (ret < 0)
  292. break;
  293. goto wait_on_recovery;
  294. case -NFS4ERR_EXPIRED:
  295. if (state != NULL) {
  296. ret = nfs4_schedule_stateid_recovery(server, state);
  297. if (ret < 0)
  298. break;
  299. }
  300. case -NFS4ERR_STALE_STATEID:
  301. case -NFS4ERR_STALE_CLIENTID:
  302. nfs4_schedule_lease_recovery(clp);
  303. goto wait_on_recovery;
  304. #if defined(CONFIG_NFS_V4_1)
  305. case -NFS4ERR_BADSESSION:
  306. case -NFS4ERR_BADSLOT:
  307. case -NFS4ERR_BAD_HIGH_SLOT:
  308. case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
  309. case -NFS4ERR_DEADSESSION:
  310. case -NFS4ERR_SEQ_FALSE_RETRY:
  311. case -NFS4ERR_SEQ_MISORDERED:
  312. dprintk("%s ERROR: %d Reset session\n", __func__,
  313. errorcode);
  314. nfs4_schedule_session_recovery(clp->cl_session, errorcode);
  315. goto wait_on_recovery;
  316. #endif /* defined(CONFIG_NFS_V4_1) */
  317. case -NFS4ERR_FILE_OPEN:
  318. if (exception->timeout > HZ) {
  319. /* We have retried a decent amount, time to
  320. * fail
  321. */
  322. ret = -EBUSY;
  323. break;
  324. }
  325. case -NFS4ERR_GRACE:
  326. case -NFS4ERR_DELAY:
  327. ret = nfs4_delay(server->client, &exception->timeout);
  328. if (ret != 0)
  329. break;
  330. case -NFS4ERR_RETRY_UNCACHED_REP:
  331. case -NFS4ERR_OLD_STATEID:
  332. exception->retry = 1;
  333. break;
  334. case -NFS4ERR_BADOWNER:
  335. /* The following works around a Linux server bug! */
  336. case -NFS4ERR_BADNAME:
  337. if (server->caps & NFS_CAP_UIDGID_NOMAP) {
  338. server->caps &= ~NFS_CAP_UIDGID_NOMAP;
  339. exception->retry = 1;
  340. printk(KERN_WARNING "NFS: v4 server %s "
  341. "does not accept raw "
  342. "uid/gids. "
  343. "Reenabling the idmapper.\n",
  344. server->nfs_client->cl_hostname);
  345. }
  346. }
  347. /* We failed to handle the error */
  348. return nfs4_map_errors(ret);
  349. wait_on_recovery:
  350. ret = nfs4_wait_clnt_recover(clp);
  351. if (ret == 0)
  352. exception->retry = 1;
  353. return ret;
  354. }
  355. static void do_renew_lease(struct nfs_client *clp, unsigned long timestamp)
  356. {
  357. spin_lock(&clp->cl_lock);
  358. if (time_before(clp->cl_last_renewal,timestamp))
  359. clp->cl_last_renewal = timestamp;
  360. spin_unlock(&clp->cl_lock);
  361. }
  362. static void renew_lease(const struct nfs_server *server, unsigned long timestamp)
  363. {
  364. do_renew_lease(server->nfs_client, timestamp);
  365. }
  366. #if defined(CONFIG_NFS_V4_1)
  367. static void nfs41_sequence_free_slot(struct nfs4_sequence_res *res)
  368. {
  369. struct nfs4_session *session;
  370. struct nfs4_slot_table *tbl;
  371. bool send_new_highest_used_slotid = false;
  372. if (!res->sr_slot) {
  373. /* just wake up the next guy waiting since
  374. * we may have not consumed a slot after all */
  375. dprintk("%s: No slot\n", __func__);
  376. return;
  377. }
  378. tbl = res->sr_slot->table;
  379. session = tbl->session;
  380. spin_lock(&tbl->slot_tbl_lock);
  381. /* Be nice to the server: try to ensure that the last transmitted
  382. * value for highest_user_slotid <= target_highest_slotid
  383. */
  384. if (tbl->highest_used_slotid > tbl->target_highest_slotid)
  385. send_new_highest_used_slotid = true;
  386. if (nfs41_wake_and_assign_slot(tbl, res->sr_slot)) {
  387. send_new_highest_used_slotid = false;
  388. goto out_unlock;
  389. }
  390. nfs4_free_slot(tbl, res->sr_slot);
  391. if (tbl->highest_used_slotid != NFS4_NO_SLOT)
  392. send_new_highest_used_slotid = false;
  393. out_unlock:
  394. spin_unlock(&tbl->slot_tbl_lock);
  395. res->sr_slot = NULL;
  396. if (send_new_highest_used_slotid)
  397. nfs41_server_notify_highest_slotid_update(session->clp);
  398. }
  399. static int nfs41_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
  400. {
  401. struct nfs4_session *session;
  402. struct nfs4_slot *slot;
  403. struct nfs_client *clp;
  404. bool interrupted = false;
  405. int ret = 1;
  406. /* don't increment the sequence number if the task wasn't sent */
  407. if (!RPC_WAS_SENT(task))
  408. goto out;
  409. slot = res->sr_slot;
  410. session = slot->table->session;
  411. if (slot->interrupted) {
  412. slot->interrupted = 0;
  413. interrupted = true;
  414. }
  415. /* Check the SEQUENCE operation status */
  416. switch (res->sr_status) {
  417. case 0:
  418. /* Update the slot's sequence and clientid lease timer */
  419. ++slot->seq_nr;
  420. clp = session->clp;
  421. do_renew_lease(clp, res->sr_timestamp);
  422. /* Check sequence flags */
  423. if (res->sr_status_flags != 0)
  424. nfs4_schedule_lease_recovery(clp);
  425. nfs41_update_target_slotid(slot->table, slot, res);
  426. break;
  427. case 1:
  428. /*
  429. * sr_status remains 1 if an RPC level error occurred.
  430. * The server may or may not have processed the sequence
  431. * operation..
  432. * Mark the slot as having hosted an interrupted RPC call.
  433. */
  434. slot->interrupted = 1;
  435. goto out;
  436. case -NFS4ERR_DELAY:
  437. /* The server detected a resend of the RPC call and
  438. * returned NFS4ERR_DELAY as per Section 2.10.6.2
  439. * of RFC5661.
  440. */
  441. dprintk("%s: slot=%u seq=%u: Operation in progress\n",
  442. __func__,
  443. slot->slot_nr,
  444. slot->seq_nr);
  445. goto out_retry;
  446. case -NFS4ERR_BADSLOT:
  447. /*
  448. * The slot id we used was probably retired. Try again
  449. * using a different slot id.
  450. */
  451. goto retry_nowait;
  452. case -NFS4ERR_SEQ_MISORDERED:
  453. /*
  454. * Was the last operation on this sequence interrupted?
  455. * If so, retry after bumping the sequence number.
  456. */
  457. if (interrupted) {
  458. ++slot->seq_nr;
  459. goto retry_nowait;
  460. }
  461. /*
  462. * Could this slot have been previously retired?
  463. * If so, then the server may be expecting seq_nr = 1!
  464. */
  465. if (slot->seq_nr != 1) {
  466. slot->seq_nr = 1;
  467. goto retry_nowait;
  468. }
  469. break;
  470. case -NFS4ERR_SEQ_FALSE_RETRY:
  471. ++slot->seq_nr;
  472. goto retry_nowait;
  473. default:
  474. /* Just update the slot sequence no. */
  475. ++slot->seq_nr;
  476. }
  477. out:
  478. /* The session may be reset by one of the error handlers. */
  479. dprintk("%s: Error %d free the slot \n", __func__, res->sr_status);
  480. nfs41_sequence_free_slot(res);
  481. return ret;
  482. retry_nowait:
  483. if (rpc_restart_call_prepare(task)) {
  484. task->tk_status = 0;
  485. ret = 0;
  486. }
  487. goto out;
  488. out_retry:
  489. if (!rpc_restart_call(task))
  490. goto out;
  491. rpc_delay(task, NFS4_POLL_RETRY_MAX);
  492. return 0;
  493. }
  494. static int nfs4_sequence_done(struct rpc_task *task,
  495. struct nfs4_sequence_res *res)
  496. {
  497. if (res->sr_slot == NULL)
  498. return 1;
  499. return nfs41_sequence_done(task, res);
  500. }
  501. static void nfs41_init_sequence(struct nfs4_sequence_args *args,
  502. struct nfs4_sequence_res *res, int cache_reply)
  503. {
  504. args->sa_slot = NULL;
  505. args->sa_cache_this = 0;
  506. args->sa_privileged = 0;
  507. if (cache_reply)
  508. args->sa_cache_this = 1;
  509. res->sr_slot = NULL;
  510. }
  511. static void nfs4_set_sequence_privileged(struct nfs4_sequence_args *args)
  512. {
  513. args->sa_privileged = 1;
  514. }
  515. int nfs41_setup_sequence(struct nfs4_session *session,
  516. struct nfs4_sequence_args *args,
  517. struct nfs4_sequence_res *res,
  518. struct rpc_task *task)
  519. {
  520. struct nfs4_slot *slot;
  521. struct nfs4_slot_table *tbl;
  522. dprintk("--> %s\n", __func__);
  523. /* slot already allocated? */
  524. if (res->sr_slot != NULL)
  525. goto out_success;
  526. tbl = &session->fc_slot_table;
  527. task->tk_timeout = 0;
  528. spin_lock(&tbl->slot_tbl_lock);
  529. if (test_bit(NFS4_SESSION_DRAINING, &session->session_state) &&
  530. !args->sa_privileged) {
  531. /* The state manager will wait until the slot table is empty */
  532. dprintk("%s session is draining\n", __func__);
  533. goto out_sleep;
  534. }
  535. slot = nfs4_alloc_slot(tbl);
  536. if (IS_ERR(slot)) {
  537. /* If out of memory, try again in 1/4 second */
  538. if (slot == ERR_PTR(-ENOMEM))
  539. task->tk_timeout = HZ >> 2;
  540. dprintk("<-- %s: no free slots\n", __func__);
  541. goto out_sleep;
  542. }
  543. spin_unlock(&tbl->slot_tbl_lock);
  544. args->sa_slot = slot;
  545. dprintk("<-- %s slotid=%d seqid=%d\n", __func__,
  546. slot->slot_nr, slot->seq_nr);
  547. res->sr_slot = slot;
  548. res->sr_timestamp = jiffies;
  549. res->sr_status_flags = 0;
  550. /*
  551. * sr_status is only set in decode_sequence, and so will remain
  552. * set to 1 if an rpc level failure occurs.
  553. */
  554. res->sr_status = 1;
  555. out_success:
  556. rpc_call_start(task);
  557. return 0;
  558. out_sleep:
  559. /* Privileged tasks are queued with top priority */
  560. if (args->sa_privileged)
  561. rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task,
  562. NULL, RPC_PRIORITY_PRIVILEGED);
  563. else
  564. rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);
  565. spin_unlock(&tbl->slot_tbl_lock);
  566. return -EAGAIN;
  567. }
  568. EXPORT_SYMBOL_GPL(nfs41_setup_sequence);
  569. int nfs4_setup_sequence(const struct nfs_server *server,
  570. struct nfs4_sequence_args *args,
  571. struct nfs4_sequence_res *res,
  572. struct rpc_task *task)
  573. {
  574. struct nfs4_session *session = nfs4_get_session(server);
  575. int ret = 0;
  576. if (session == NULL) {
  577. rpc_call_start(task);
  578. goto out;
  579. }
  580. dprintk("--> %s clp %p session %p sr_slot %d\n",
  581. __func__, session->clp, session, res->sr_slot ?
  582. res->sr_slot->slot_nr : -1);
  583. ret = nfs41_setup_sequence(session, args, res, task);
  584. out:
  585. dprintk("<-- %s status=%d\n", __func__, ret);
  586. return ret;
  587. }
  588. struct nfs41_call_sync_data {
  589. const struct nfs_server *seq_server;
  590. struct nfs4_sequence_args *seq_args;
  591. struct nfs4_sequence_res *seq_res;
  592. };
  593. static void nfs41_call_sync_prepare(struct rpc_task *task, void *calldata)
  594. {
  595. struct nfs41_call_sync_data *data = calldata;
  596. struct nfs4_session *session = nfs4_get_session(data->seq_server);
  597. dprintk("--> %s data->seq_server %p\n", __func__, data->seq_server);
  598. nfs41_setup_sequence(session, data->seq_args, data->seq_res, task);
  599. }
  600. static void nfs41_call_sync_done(struct rpc_task *task, void *calldata)
  601. {
  602. struct nfs41_call_sync_data *data = calldata;
  603. nfs41_sequence_done(task, data->seq_res);
  604. }
  605. static const struct rpc_call_ops nfs41_call_sync_ops = {
  606. .rpc_call_prepare = nfs41_call_sync_prepare,
  607. .rpc_call_done = nfs41_call_sync_done,
  608. };
  609. static int nfs4_call_sync_sequence(struct rpc_clnt *clnt,
  610. struct nfs_server *server,
  611. struct rpc_message *msg,
  612. struct nfs4_sequence_args *args,
  613. struct nfs4_sequence_res *res)
  614. {
  615. int ret;
  616. struct rpc_task *task;
  617. struct nfs41_call_sync_data data = {
  618. .seq_server = server,
  619. .seq_args = args,
  620. .seq_res = res,
  621. };
  622. struct rpc_task_setup task_setup = {
  623. .rpc_client = clnt,
  624. .rpc_message = msg,
  625. .callback_ops = &nfs41_call_sync_ops,
  626. .callback_data = &data
  627. };
  628. task = rpc_run_task(&task_setup);
  629. if (IS_ERR(task))
  630. ret = PTR_ERR(task);
  631. else {
  632. ret = task->tk_status;
  633. rpc_put_task(task);
  634. }
  635. return ret;
  636. }
  637. #else
  638. static
  639. void nfs41_init_sequence(struct nfs4_sequence_args *args,
  640. struct nfs4_sequence_res *res, int cache_reply)
  641. {
  642. }
  643. static void nfs4_set_sequence_privileged(struct nfs4_sequence_args *args)
  644. {
  645. }
  646. static int nfs4_sequence_done(struct rpc_task *task,
  647. struct nfs4_sequence_res *res)
  648. {
  649. return 1;
  650. }
  651. #endif /* CONFIG_NFS_V4_1 */
  652. static
  653. int _nfs4_call_sync(struct rpc_clnt *clnt,
  654. struct nfs_server *server,
  655. struct rpc_message *msg,
  656. struct nfs4_sequence_args *args,
  657. struct nfs4_sequence_res *res)
  658. {
  659. return rpc_call_sync(clnt, msg, 0);
  660. }
  661. static
  662. int nfs4_call_sync(struct rpc_clnt *clnt,
  663. struct nfs_server *server,
  664. struct rpc_message *msg,
  665. struct nfs4_sequence_args *args,
  666. struct nfs4_sequence_res *res,
  667. int cache_reply)
  668. {
  669. nfs41_init_sequence(args, res, cache_reply);
  670. return server->nfs_client->cl_mvops->call_sync(clnt, server, msg,
  671. args, res);
  672. }
  673. static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo)
  674. {
  675. struct nfs_inode *nfsi = NFS_I(dir);
  676. spin_lock(&dir->i_lock);
  677. nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
  678. if (!cinfo->atomic || cinfo->before != dir->i_version)
  679. nfs_force_lookup_revalidate(dir);
  680. dir->i_version = cinfo->after;
  681. nfs_fscache_invalidate(dir);
  682. spin_unlock(&dir->i_lock);
  683. }
  684. struct nfs4_opendata {
  685. struct kref kref;
  686. struct nfs_openargs o_arg;
  687. struct nfs_openres o_res;
  688. struct nfs_open_confirmargs c_arg;
  689. struct nfs_open_confirmres c_res;
  690. struct nfs4_string owner_name;
  691. struct nfs4_string group_name;
  692. struct nfs_fattr f_attr;
  693. struct dentry *dir;
  694. struct dentry *dentry;
  695. struct nfs4_state_owner *owner;
  696. struct nfs4_state *state;
  697. struct iattr attrs;
  698. unsigned long timestamp;
  699. unsigned int rpc_done : 1;
  700. int rpc_status;
  701. int cancelled;
  702. };
  703. static bool nfs4_clear_cap_atomic_open_v1(struct nfs_server *server,
  704. int err, struct nfs4_exception *exception)
  705. {
  706. if (err != -EINVAL)
  707. return false;
  708. if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1))
  709. return false;
  710. server->caps &= ~NFS_CAP_ATOMIC_OPEN_V1;
  711. exception->retry = 1;
  712. return true;
  713. }
  714. static enum open_claim_type4
  715. nfs4_map_atomic_open_claim(struct nfs_server *server,
  716. enum open_claim_type4 claim)
  717. {
  718. if (server->caps & NFS_CAP_ATOMIC_OPEN_V1)
  719. return claim;
  720. switch (claim) {
  721. default:
  722. return claim;
  723. case NFS4_OPEN_CLAIM_FH:
  724. return NFS4_OPEN_CLAIM_NULL;
  725. case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
  726. return NFS4_OPEN_CLAIM_DELEGATE_CUR;
  727. case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
  728. return NFS4_OPEN_CLAIM_DELEGATE_PREV;
  729. }
  730. }
  731. static void nfs4_init_opendata_res(struct nfs4_opendata *p)
  732. {
  733. p->o_res.f_attr = &p->f_attr;
  734. p->o_res.seqid = p->o_arg.seqid;
  735. p->c_res.seqid = p->c_arg.seqid;
  736. p->o_res.server = p->o_arg.server;
  737. p->o_res.access_request = p->o_arg.access;
  738. nfs_fattr_init(&p->f_attr);
  739. nfs_fattr_init_names(&p->f_attr, &p->owner_name, &p->group_name);
  740. }
  741. static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
  742. struct nfs4_state_owner *sp, fmode_t fmode, int flags,
  743. const struct iattr *attrs,
  744. enum open_claim_type4 claim,
  745. gfp_t gfp_mask)
  746. {
  747. struct dentry *parent = dget_parent(dentry);
  748. struct inode *dir = parent->d_inode;
  749. struct nfs_server *server = NFS_SERVER(dir);
  750. struct nfs4_opendata *p;
  751. p = kzalloc(sizeof(*p), gfp_mask);
  752. if (p == NULL)
  753. goto err;
  754. p->o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid, gfp_mask);
  755. if (p->o_arg.seqid == NULL)
  756. goto err_free;
  757. nfs_sb_active(dentry->d_sb);
  758. p->dentry = dget(dentry);
  759. p->dir = parent;
  760. p->owner = sp;
  761. atomic_inc(&sp->so_count);
  762. p->o_arg.open_flags = flags;
  763. p->o_arg.fmode = fmode & (FMODE_READ|FMODE_WRITE);
  764. /* don't put an ACCESS op in OPEN compound if O_EXCL, because ACCESS
  765. * will return permission denied for all bits until close */
  766. if (!(flags & O_EXCL)) {
  767. /* ask server to check for all possible rights as results
  768. * are cached */
  769. p->o_arg.access = NFS4_ACCESS_READ | NFS4_ACCESS_MODIFY |
  770. NFS4_ACCESS_EXTEND | NFS4_ACCESS_EXECUTE;
  771. }
  772. p->o_arg.clientid = server->nfs_client->cl_clientid;
  773. p->o_arg.id.create_time = ktime_to_ns(sp->so_seqid.create_time);
  774. p->o_arg.id.uniquifier = sp->so_seqid.owner_id;
  775. p->o_arg.name = &dentry->d_name;
  776. p->o_arg.server = server;
  777. p->o_arg.bitmask = server->attr_bitmask;
  778. p->o_arg.open_bitmap = &nfs4_fattr_bitmap[0];
  779. p->o_arg.claim = nfs4_map_atomic_open_claim(server, claim);
  780. switch (p->o_arg.claim) {
  781. case NFS4_OPEN_CLAIM_NULL:
  782. case NFS4_OPEN_CLAIM_DELEGATE_CUR:
  783. case NFS4_OPEN_CLAIM_DELEGATE_PREV:
  784. p->o_arg.fh = NFS_FH(dir);
  785. break;
  786. case NFS4_OPEN_CLAIM_PREVIOUS:
  787. case NFS4_OPEN_CLAIM_FH:
  788. case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
  789. case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
  790. p->o_arg.fh = NFS_FH(dentry->d_inode);
  791. }
  792. if (attrs != NULL && attrs->ia_valid != 0) {
  793. __be32 verf[2];
  794. p->o_arg.u.attrs = &p->attrs;
  795. memcpy(&p->attrs, attrs, sizeof(p->attrs));
  796. verf[0] = jiffies;
  797. verf[1] = current->pid;
  798. memcpy(p->o_arg.u.verifier.data, verf,
  799. sizeof(p->o_arg.u.verifier.data));
  800. }
  801. p->c_arg.fh = &p->o_res.fh;
  802. p->c_arg.stateid = &p->o_res.stateid;
  803. p->c_arg.seqid = p->o_arg.seqid;
  804. nfs4_init_opendata_res(p);
  805. kref_init(&p->kref);
  806. return p;
  807. err_free:
  808. kfree(p);
  809. err:
  810. dput(parent);
  811. return NULL;
  812. }
  813. static void nfs4_opendata_free(struct kref *kref)
  814. {
  815. struct nfs4_opendata *p = container_of(kref,
  816. struct nfs4_opendata, kref);
  817. struct super_block *sb = p->dentry->d_sb;
  818. nfs_free_seqid(p->o_arg.seqid);
  819. if (p->state != NULL)
  820. nfs4_put_open_state(p->state);
  821. nfs4_put_state_owner(p->owner);
  822. dput(p->dir);
  823. dput(p->dentry);
  824. nfs_sb_deactive(sb);
  825. nfs_fattr_free_names(&p->f_attr);
  826. kfree(p);
  827. }
  828. static void nfs4_opendata_put(struct nfs4_opendata *p)
  829. {
  830. if (p != NULL)
  831. kref_put(&p->kref, nfs4_opendata_free);
  832. }
  833. static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task)
  834. {
  835. int ret;
  836. ret = rpc_wait_for_completion_task(task);
  837. return ret;
  838. }
  839. static int can_open_cached(struct nfs4_state *state, fmode_t mode, int open_mode)
  840. {
  841. int ret = 0;
  842. if (open_mode & (O_EXCL|O_TRUNC))
  843. goto out;
  844. switch (mode & (FMODE_READ|FMODE_WRITE)) {
  845. case FMODE_READ:
  846. ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0
  847. && state->n_rdonly != 0;
  848. break;
  849. case FMODE_WRITE:
  850. ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0
  851. && state->n_wronly != 0;
  852. break;
  853. case FMODE_READ|FMODE_WRITE:
  854. ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0
  855. && state->n_rdwr != 0;
  856. }
  857. out:
  858. return ret;
  859. }
  860. static int can_open_delegated(struct nfs_delegation *delegation, fmode_t fmode)
  861. {
  862. if (delegation == NULL)
  863. return 0;
  864. if ((delegation->type & fmode) != fmode)
  865. return 0;
  866. if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags))
  867. return 0;
  868. if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
  869. return 0;
  870. nfs_mark_delegation_referenced(delegation);
  871. return 1;
  872. }
  873. static void update_open_stateflags(struct nfs4_state *state, fmode_t fmode)
  874. {
  875. switch (fmode) {
  876. case FMODE_WRITE:
  877. state->n_wronly++;
  878. break;
  879. case FMODE_READ:
  880. state->n_rdonly++;
  881. break;
  882. case FMODE_READ|FMODE_WRITE:
  883. state->n_rdwr++;
  884. }
  885. nfs4_state_set_mode_locked(state, state->state | fmode);
  886. }
  887. static void nfs_set_open_stateid_locked(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode)
  888. {
  889. if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
  890. nfs4_stateid_copy(&state->stateid, stateid);
  891. nfs4_stateid_copy(&state->open_stateid, stateid);
  892. set_bit(NFS_OPEN_STATE, &state->flags);
  893. switch (fmode) {
  894. case FMODE_READ:
  895. set_bit(NFS_O_RDONLY_STATE, &state->flags);
  896. break;
  897. case FMODE_WRITE:
  898. set_bit(NFS_O_WRONLY_STATE, &state->flags);
  899. break;
  900. case FMODE_READ|FMODE_WRITE:
  901. set_bit(NFS_O_RDWR_STATE, &state->flags);
  902. }
  903. }
  904. static void nfs_set_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode)
  905. {
  906. write_seqlock(&state->seqlock);
  907. nfs_set_open_stateid_locked(state, stateid, fmode);
  908. write_sequnlock(&state->seqlock);
  909. }
  910. static void __update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, const nfs4_stateid *deleg_stateid, fmode_t fmode)
  911. {
  912. /*
  913. * Protect the call to nfs4_state_set_mode_locked and
  914. * serialise the stateid update
  915. */
  916. write_seqlock(&state->seqlock);
  917. if (deleg_stateid != NULL) {
  918. nfs4_stateid_copy(&state->stateid, deleg_stateid);
  919. set_bit(NFS_DELEGATED_STATE, &state->flags);
  920. }
  921. if (open_stateid != NULL)
  922. nfs_set_open_stateid_locked(state, open_stateid, fmode);
  923. write_sequnlock(&state->seqlock);
  924. spin_lock(&state->owner->so_lock);
  925. update_open_stateflags(state, fmode);
  926. spin_unlock(&state->owner->so_lock);
  927. }
  928. static int update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, nfs4_stateid *delegation, fmode_t fmode)
  929. {
  930. struct nfs_inode *nfsi = NFS_I(state->inode);
  931. struct nfs_delegation *deleg_cur;
  932. int ret = 0;
  933. fmode &= (FMODE_READ|FMODE_WRITE);
  934. rcu_read_lock();
  935. deleg_cur = rcu_dereference(nfsi->delegation);
  936. if (deleg_cur == NULL)
  937. goto no_delegation;
  938. spin_lock(&deleg_cur->lock);
  939. if (nfsi->delegation != deleg_cur ||
  940. test_bit(NFS_DELEGATION_RETURNING, &deleg_cur->flags) ||
  941. (deleg_cur->type & fmode) != fmode)
  942. goto no_delegation_unlock;
  943. if (delegation == NULL)
  944. delegation = &deleg_cur->stateid;
  945. else if (!nfs4_stateid_match(&deleg_cur->stateid, delegation))
  946. goto no_delegation_unlock;
  947. nfs_mark_delegation_referenced(deleg_cur);
  948. __update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode);
  949. ret = 1;
  950. no_delegation_unlock:
  951. spin_unlock(&deleg_cur->lock);
  952. no_delegation:
  953. rcu_read_unlock();
  954. if (!ret && open_stateid != NULL) {
  955. __update_open_stateid(state, open_stateid, NULL, fmode);
  956. ret = 1;
  957. }
  958. return ret;
  959. }
  960. static void nfs4_return_incompatible_delegation(struct inode *inode, fmode_t fmode)
  961. {
  962. struct nfs_delegation *delegation;
  963. rcu_read_lock();
  964. delegation = rcu_dereference(NFS_I(inode)->delegation);
  965. if (delegation == NULL || (delegation->type & fmode) == fmode) {
  966. rcu_read_unlock();
  967. return;
  968. }
  969. rcu_read_unlock();
  970. nfs4_inode_return_delegation(inode);
  971. }
  972. static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)
  973. {
  974. struct nfs4_state *state = opendata->state;
  975. struct nfs_inode *nfsi = NFS_I(state->inode);
  976. struct nfs_delegation *delegation;
  977. int open_mode = opendata->o_arg.open_flags & (O_EXCL|O_TRUNC);
  978. fmode_t fmode = opendata->o_arg.fmode;
  979. nfs4_stateid stateid;
  980. int ret = -EAGAIN;
  981. for (;;) {
  982. if (can_open_cached(state, fmode, open_mode)) {
  983. spin_lock(&state->owner->so_lock);
  984. if (can_open_cached(state, fmode, open_mode)) {
  985. update_open_stateflags(state, fmode);
  986. spin_unlock(&state->owner->so_lock);
  987. goto out_return_state;
  988. }
  989. spin_unlock(&state->owner->so_lock);
  990. }
  991. rcu_read_lock();
  992. delegation = rcu_dereference(nfsi->delegation);
  993. if (!can_open_delegated(delegation, fmode)) {
  994. rcu_read_unlock();
  995. break;
  996. }
  997. /* Save the delegation */
  998. nfs4_stateid_copy(&stateid, &delegation->stateid);
  999. rcu_read_unlock();
  1000. ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode);
  1001. if (ret != 0)
  1002. goto out;
  1003. ret = -EAGAIN;
  1004. /* Try to update the stateid using the delegation */
  1005. if (update_open_stateid(state, NULL, &stateid, fmode))
  1006. goto out_return_state;
  1007. }
  1008. out:
  1009. return ERR_PTR(ret);
  1010. out_return_state:
  1011. atomic_inc(&state->count);
  1012. return state;
  1013. }
  1014. static void
  1015. nfs4_opendata_check_deleg(struct nfs4_opendata *data, struct nfs4_state *state)
  1016. {
  1017. struct nfs_client *clp = NFS_SERVER(state->inode)->nfs_client;
  1018. struct nfs_delegation *delegation;
  1019. int delegation_flags = 0;
  1020. rcu_read_lock();
  1021. delegation = rcu_dereference(NFS_I(state->inode)->delegation);
  1022. if (delegation)
  1023. delegation_flags = delegation->flags;
  1024. rcu_read_unlock();
  1025. if (data->o_arg.claim == NFS4_OPEN_CLAIM_DELEGATE_CUR) {
  1026. pr_err_ratelimited("NFS: Broken NFSv4 server %s is "
  1027. "returning a delegation for "
  1028. "OPEN(CLAIM_DELEGATE_CUR)\n",
  1029. clp->cl_hostname);
  1030. } else if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0)
  1031. nfs_inode_set_delegation(state->inode,
  1032. data->owner->so_cred,
  1033. &data->o_res);
  1034. else
  1035. nfs_inode_reclaim_delegation(state->inode,
  1036. data->owner->so_cred,
  1037. &data->o_res);
  1038. }
  1039. /*
  1040. * Check the inode attributes against the CLAIM_PREVIOUS returned attributes
  1041. * and update the nfs4_state.
  1042. */
  1043. static struct nfs4_state *
  1044. _nfs4_opendata_reclaim_to_nfs4_state(struct nfs4_opendata *data)
  1045. {
  1046. struct inode *inode = data->state->inode;
  1047. struct nfs4_state *state = data->state;
  1048. int ret;
  1049. if (!data->rpc_done) {
  1050. ret = data->rpc_status;
  1051. goto err;
  1052. }
  1053. ret = -ESTALE;
  1054. if (!(data->f_attr.valid & NFS_ATTR_FATTR_TYPE) ||
  1055. !(data->f_attr.valid & NFS_ATTR_FATTR_FILEID) ||
  1056. !(data->f_attr.valid & NFS_ATTR_FATTR_CHANGE))
  1057. goto err;
  1058. ret = -ENOMEM;
  1059. state = nfs4_get_open_state(inode, data->owner);
  1060. if (state == NULL)
  1061. goto err;
  1062. ret = nfs_refresh_inode(inode, &data->f_attr);
  1063. if (ret)
  1064. goto err;
  1065. if (data->o_res.delegation_type != 0)
  1066. nfs4_opendata_check_deleg(data, state);
  1067. update_open_stateid(state, &data->o_res.stateid, NULL,
  1068. data->o_arg.fmode);
  1069. return state;
  1070. err:
  1071. return ERR_PTR(ret);
  1072. }
  1073. static struct nfs4_state *
  1074. _nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
  1075. {
  1076. struct inode *inode;
  1077. struct nfs4_state *state = NULL;
  1078. int ret;
  1079. if (!data->rpc_done) {
  1080. state = nfs4_try_open_cached(data);
  1081. goto out;
  1082. }
  1083. ret = -EAGAIN;
  1084. if (!(data->f_attr.valid & NFS_ATTR_FATTR))
  1085. goto err;
  1086. inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr);
  1087. ret = PTR_ERR(inode);
  1088. if (IS_ERR(inode))
  1089. goto err;
  1090. ret = -ENOMEM;
  1091. state = nfs4_get_open_state(inode, data->owner);
  1092. if (state == NULL)
  1093. goto err_put_inode;
  1094. if (data->o_res.delegation_type != 0)
  1095. nfs4_opendata_check_deleg(data, state);
  1096. update_open_stateid(state, &data->o_res.stateid, NULL,
  1097. data->o_arg.fmode);
  1098. iput(inode);
  1099. out:
  1100. nfs_release_seqid(data->o_arg.seqid);
  1101. return state;
  1102. err_put_inode:
  1103. iput(inode);
  1104. err:
  1105. return ERR_PTR(ret);
  1106. }
  1107. static struct nfs4_state *
  1108. nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
  1109. {
  1110. if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS)
  1111. return _nfs4_opendata_reclaim_to_nfs4_state(data);
  1112. return _nfs4_opendata_to_nfs4_state(data);
  1113. }
  1114. static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state)
  1115. {
  1116. struct nfs_inode *nfsi = NFS_I(state->inode);
  1117. struct nfs_open_context *ctx;
  1118. spin_lock(&state->inode->i_lock);
  1119. list_for_each_entry(ctx, &nfsi->open_files, list) {
  1120. if (ctx->state != state)
  1121. continue;
  1122. get_nfs_open_context(ctx);
  1123. spin_unlock(&state->inode->i_lock);
  1124. return ctx;
  1125. }
  1126. spin_unlock(&state->inode->i_lock);
  1127. return ERR_PTR(-ENOENT);
  1128. }
  1129. static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context *ctx,
  1130. struct nfs4_state *state, enum open_claim_type4 claim)
  1131. {
  1132. struct nfs4_opendata *opendata;
  1133. opendata = nfs4_opendata_alloc(ctx->dentry, state->owner, 0, 0,
  1134. NULL, claim, GFP_NOFS);
  1135. if (opendata == NULL)
  1136. return ERR_PTR(-ENOMEM);
  1137. opendata->state = state;
  1138. atomic_inc(&state->count);
  1139. return opendata;
  1140. }
  1141. static int nfs4_open_recover_helper(struct nfs4_opendata *opendata, fmode_t fmode, struct nfs4_state **res)
  1142. {
  1143. struct nfs4_state *newstate;
  1144. int ret;
  1145. opendata->o_arg.open_flags = 0;
  1146. opendata->o_arg.fmode = fmode;
  1147. memset(&opendata->o_res, 0, sizeof(opendata->o_res));
  1148. memset(&opendata->c_res, 0, sizeof(opendata->c_res));
  1149. nfs4_init_opendata_res(opendata);
  1150. ret = _nfs4_recover_proc_open(opendata);
  1151. if (ret != 0)
  1152. return ret;
  1153. newstate = nfs4_opendata_to_nfs4_state(opendata);
  1154. if (IS_ERR(newstate))
  1155. return PTR_ERR(newstate);
  1156. nfs4_close_state(newstate, fmode);
  1157. *res = newstate;
  1158. return 0;
  1159. }
  1160. static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state)
  1161. {
  1162. struct nfs4_state *newstate;
  1163. int ret;
  1164. /* memory barrier prior to reading state->n_* */
  1165. clear_bit(NFS_DELEGATED_STATE, &state->flags);
  1166. clear_bit(NFS_OPEN_STATE, &state->flags);
  1167. smp_rmb();
  1168. if (state->n_rdwr != 0) {
  1169. clear_bit(NFS_O_RDWR_STATE, &state->flags);
  1170. ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE, &newstate);
  1171. if (ret != 0)
  1172. return ret;
  1173. if (newstate != state)
  1174. return -ESTALE;
  1175. }
  1176. if (state->n_wronly != 0) {
  1177. clear_bit(NFS_O_WRONLY_STATE, &state->flags);
  1178. ret = nfs4_open_recover_helper(opendata, FMODE_WRITE, &newstate);
  1179. if (ret != 0)
  1180. return ret;
  1181. if (newstate != state)
  1182. return -ESTALE;
  1183. }
  1184. if (state->n_rdonly != 0) {
  1185. clear_bit(NFS_O_RDONLY_STATE, &state->flags);
  1186. ret = nfs4_open_recover_helper(opendata, FMODE_READ, &newstate);
  1187. if (ret != 0)
  1188. return ret;
  1189. if (newstate != state)
  1190. return -ESTALE;
  1191. }
  1192. /*
  1193. * We may have performed cached opens for all three recoveries.
  1194. * Check if we need to update the current stateid.
  1195. */
  1196. if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 &&
  1197. !nfs4_stateid_match(&state->stateid, &state->open_stateid)) {
  1198. write_seqlock(&state->seqlock);
  1199. if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
  1200. nfs4_stateid_copy(&state->stateid, &state->open_stateid);
  1201. write_sequnlock(&state->seqlock);
  1202. }
  1203. return 0;
  1204. }
  1205. /*
  1206. * OPEN_RECLAIM:
  1207. * reclaim state on the server after a reboot.
  1208. */
  1209. static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
  1210. {
  1211. struct nfs_delegation *delegation;
  1212. struct nfs4_opendata *opendata;
  1213. fmode_t delegation_type = 0;
  1214. int status;
  1215. opendata = nfs4_open_recoverdata_alloc(ctx, state,
  1216. NFS4_OPEN_CLAIM_PREVIOUS);
  1217. if (IS_ERR(opendata))
  1218. return PTR_ERR(opendata);
  1219. rcu_read_lock();
  1220. delegation = rcu_dereference(NFS_I(state->inode)->delegation);
  1221. if (delegation != NULL && test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) != 0)
  1222. delegation_type = delegation->type;
  1223. rcu_read_unlock();
  1224. opendata->o_arg.u.delegation_type = delegation_type;
  1225. status = nfs4_open_recover(opendata, state);
  1226. nfs4_opendata_put(opendata);
  1227. return status;
  1228. }
  1229. static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
  1230. {
  1231. struct nfs_server *server = NFS_SERVER(state->inode);
  1232. struct nfs4_exception exception = { };
  1233. int err;
  1234. do {
  1235. err = _nfs4_do_open_reclaim(ctx, state);
  1236. if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
  1237. continue;
  1238. if (err != -NFS4ERR_DELAY)
  1239. break;
  1240. nfs4_handle_exception(server, err, &exception);
  1241. } while (exception.retry);
  1242. return err;
  1243. }
  1244. static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state)
  1245. {
  1246. struct nfs_open_context *ctx;
  1247. int ret;
  1248. ctx = nfs4_state_find_open_context(state);
  1249. if (IS_ERR(ctx))
  1250. return -EAGAIN;
  1251. ret = nfs4_do_open_reclaim(ctx, state);
  1252. put_nfs_open_context(ctx);
  1253. return ret;
  1254. }
  1255. static int nfs4_handle_delegation_recall_error(struct nfs_server *server, struct nfs4_state *state, const nfs4_stateid *stateid, int err)
  1256. {
  1257. switch (err) {
  1258. default:
  1259. printk(KERN_ERR "NFS: %s: unhandled error "
  1260. "%d.\n", __func__, err);
  1261. case 0:
  1262. case -ENOENT:
  1263. case -ESTALE:
  1264. break;
  1265. case -NFS4ERR_BADSESSION:
  1266. case -NFS4ERR_BADSLOT:
  1267. case -NFS4ERR_BAD_HIGH_SLOT:
  1268. case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
  1269. case -NFS4ERR_DEADSESSION:
  1270. set_bit(NFS_DELEGATED_STATE, &state->flags);
  1271. nfs4_schedule_session_recovery(server->nfs_client->cl_session, err);
  1272. return -EAGAIN;
  1273. case -NFS4ERR_STALE_CLIENTID:
  1274. case -NFS4ERR_STALE_STATEID:
  1275. set_bit(NFS_DELEGATED_STATE, &state->flags);
  1276. case -NFS4ERR_EXPIRED:
  1277. /* Don't recall a delegation if it was lost */
  1278. nfs4_schedule_lease_recovery(server->nfs_client);
  1279. return -EAGAIN;
  1280. case -NFS4ERR_DELEG_REVOKED:
  1281. case -NFS4ERR_ADMIN_REVOKED:
  1282. case -NFS4ERR_BAD_STATEID:
  1283. case -NFS4ERR_OPENMODE:
  1284. nfs_inode_find_state_and_recover(state->inode,
  1285. stateid);
  1286. nfs4_schedule_stateid_recovery(server, state);
  1287. return 0;
  1288. case -NFS4ERR_DELAY:
  1289. case -NFS4ERR_GRACE:
  1290. set_bit(NFS_DELEGATED_STATE, &state->flags);
  1291. ssleep(1);
  1292. return -EAGAIN;
  1293. case -ENOMEM:
  1294. case -NFS4ERR_DENIED:
  1295. /* kill_proc(fl->fl_pid, SIGLOST, 1); */
  1296. return 0;
  1297. }
  1298. return err;
  1299. }
  1300. int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
  1301. {
  1302. struct nfs_server *server = NFS_SERVER(state->inode);
  1303. struct nfs4_opendata *opendata;
  1304. int err;
  1305. opendata = nfs4_open_recoverdata_alloc(ctx, state,
  1306. NFS4_OPEN_CLAIM_DELEG_CUR_FH);
  1307. if (IS_ERR(opendata))
  1308. return PTR_ERR(opendata);
  1309. nfs4_stateid_copy(&opendata->o_arg.u.delegation, stateid);
  1310. err = nfs4_open_recover(opendata, state);
  1311. nfs4_opendata_put(opendata);
  1312. return nfs4_handle_delegation_recall_error(server, state, stateid, err);
  1313. }
  1314. static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)
  1315. {
  1316. struct nfs4_opendata *data = calldata;
  1317. data->rpc_status = task->tk_status;
  1318. if (data->rpc_status == 0) {
  1319. nfs4_stateid_copy(&data->o_res.stateid, &data->c_res.stateid);
  1320. nfs_confirm_seqid(&data->owner->so_seqid, 0);
  1321. renew_lease(data->o_res.server, data->timestamp);
  1322. data->rpc_done = 1;
  1323. }
  1324. }
  1325. static void nfs4_open_confirm_release(void *calldata)
  1326. {
  1327. struct nfs4_opendata *data = calldata;
  1328. struct nfs4_state *state = NULL;
  1329. /* If this request hasn't been cancelled, do nothing */
  1330. if (data->cancelled == 0)
  1331. goto out_free;
  1332. /* In case of error, no cleanup! */
  1333. if (!data->rpc_done)
  1334. goto out_free;
  1335. state = nfs4_opendata_to_nfs4_state(data);
  1336. if (!IS_ERR(state))
  1337. nfs4_close_state(state, data->o_arg.fmode);
  1338. out_free:
  1339. nfs4_opendata_put(data);
  1340. }
  1341. static const struct rpc_call_ops nfs4_open_confirm_ops = {
  1342. .rpc_call_done = nfs4_open_confirm_done,
  1343. .rpc_release = nfs4_open_confirm_release,
  1344. };
  1345. /*
  1346. * Note: On error, nfs4_proc_open_confirm will free the struct nfs4_opendata
  1347. */
  1348. static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
  1349. {
  1350. struct nfs_server *server = NFS_SERVER(data->dir->d_inode);
  1351. struct rpc_task *task;
  1352. struct rpc_message msg = {
  1353. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM],
  1354. .rpc_argp = &data->c_arg,
  1355. .rpc_resp = &data->c_res,
  1356. .rpc_cred = data->owner->so_cred,
  1357. };
  1358. struct rpc_task_setup task_setup_data = {
  1359. .rpc_client = server->client,
  1360. .rpc_message = &msg,
  1361. .callback_ops = &nfs4_open_confirm_ops,
  1362. .callback_data = data,
  1363. .workqueue = nfsiod_workqueue,
  1364. .flags = RPC_TASK_ASYNC,
  1365. };
  1366. int status;
  1367. kref_get(&data->kref);
  1368. data->rpc_done = 0;
  1369. data->rpc_status = 0;
  1370. data->timestamp = jiffies;
  1371. task = rpc_run_task(&task_setup_data);
  1372. if (IS_ERR(task))
  1373. return PTR_ERR(task);
  1374. status = nfs4_wait_for_completion_rpc_task(task);
  1375. if (status != 0) {
  1376. data->cancelled = 1;
  1377. smp_wmb();
  1378. } else
  1379. status = data->rpc_status;
  1380. rpc_put_task(task);
  1381. return status;
  1382. }
  1383. static void nfs4_open_prepare(struct rpc_task *task, void *calldata)
  1384. {
  1385. struct nfs4_opendata *data = calldata;
  1386. struct nfs4_state_owner *sp = data->owner;
  1387. struct nfs_client *clp = sp->so_server->nfs_client;
  1388. if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0)
  1389. goto out_wait;
  1390. /*
  1391. * Check if we still need to send an OPEN call, or if we can use
  1392. * a delegation instead.
  1393. */
  1394. if (data->state != NULL) {
  1395. struct nfs_delegation *delegation;
  1396. if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags))
  1397. goto out_no_action;
  1398. rcu_read_lock();
  1399. delegation = rcu_dereference(NFS_I(data->state->inode)->delegation);
  1400. if (data->o_arg.claim != NFS4_OPEN_CLAIM_DELEGATE_CUR &&
  1401. data->o_arg.claim != NFS4_OPEN_CLAIM_DELEG_CUR_FH &&
  1402. can_open_delegated(delegation, data->o_arg.fmode))
  1403. goto unlock_no_action;
  1404. rcu_read_unlock();
  1405. }
  1406. /* Update client id. */
  1407. data->o_arg.clientid = clp->cl_clientid;
  1408. switch (data->o_arg.claim) {
  1409. case NFS4_OPEN_CLAIM_PREVIOUS:
  1410. case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
  1411. case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
  1412. data->o_arg.open_bitmap = &nfs4_open_noattr_bitmap[0];
  1413. case NFS4_OPEN_CLAIM_FH:
  1414. task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR];
  1415. nfs_copy_fh(&data->o_res.fh, data->o_arg.fh);
  1416. }
  1417. data->timestamp = jiffies;
  1418. if (nfs4_setup_sequence(data->o_arg.server,
  1419. &data->o_arg.seq_args,
  1420. &data->o_res.seq_res,
  1421. task) != 0)
  1422. nfs_release_seqid(data->o_arg.seqid);
  1423. /* Set the create mode (note dependency on the session type) */
  1424. data->o_arg.createmode = NFS4_CREATE_UNCHECKED;
  1425. if (data->o_arg.open_flags & O_EXCL) {
  1426. data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE;
  1427. if (nfs4_has_persistent_session(clp))
  1428. data->o_arg.createmode = NFS4_CREATE_GUARDED;
  1429. else if (clp->cl_mvops->minor_version > 0)
  1430. data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE4_1;
  1431. }
  1432. return;
  1433. unlock_no_action:
  1434. rcu_read_unlock();
  1435. out_no_action:
  1436. task->tk_action = NULL;
  1437. out_wait:
  1438. nfs4_sequence_done(task, &data->o_res.seq_res);
  1439. }
  1440. static void nfs4_open_done(struct rpc_task *task, void *calldata)
  1441. {
  1442. struct nfs4_opendata *data = calldata;
  1443. data->rpc_status = task->tk_status;
  1444. if (!nfs4_sequence_done(task, &data->o_res.seq_res))
  1445. return;
  1446. if (task->tk_status == 0) {
  1447. if (data->o_res.f_attr->valid & NFS_ATTR_FATTR_TYPE) {
  1448. switch (data->o_res.f_attr->mode & S_IFMT) {
  1449. case S_IFREG:
  1450. break;
  1451. case S_IFLNK:
  1452. data->rpc_status = -ELOOP;
  1453. break;
  1454. case S_IFDIR:
  1455. data->rpc_status = -EISDIR;
  1456. break;
  1457. default:
  1458. data->rpc_status = -ENOTDIR;
  1459. }
  1460. }
  1461. renew_lease(data->o_res.server, data->timestamp);
  1462. if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM))
  1463. nfs_confirm_seqid(&data->owner->so_seqid, 0);
  1464. }
  1465. data->rpc_done = 1;
  1466. }
  1467. static void nfs4_open_release(void *calldata)
  1468. {
  1469. struct nfs4_opendata *data = calldata;
  1470. struct nfs4_state *state = NULL;
  1471. /* If this request hasn't been cancelled, do nothing */
  1472. if (data->cancelled == 0)
  1473. goto out_free;
  1474. /* In case of error, no cleanup! */
  1475. if (data->rpc_status != 0 || !data->rpc_done)
  1476. goto out_free;
  1477. /* In case we need an open_confirm, no cleanup! */
  1478. if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)
  1479. goto out_free;
  1480. state = nfs4_opendata_to_nfs4_state(data);
  1481. if (!IS_ERR(state))
  1482. nfs4_close_state(state, data->o_arg.fmode);
  1483. out_free:
  1484. nfs4_opendata_put(data);
  1485. }
  1486. static const struct rpc_call_ops nfs4_open_ops = {
  1487. .rpc_call_prepare = nfs4_open_prepare,
  1488. .rpc_call_done = nfs4_open_done,
  1489. .rpc_release = nfs4_open_release,
  1490. };
  1491. static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover)
  1492. {
  1493. struct inode *dir = data->dir->d_inode;
  1494. struct nfs_server *server = NFS_SERVER(dir);
  1495. struct nfs_openargs *o_arg = &data->o_arg;
  1496. struct nfs_openres *o_res = &data->o_res;
  1497. struct rpc_task *task;
  1498. struct rpc_message msg = {
  1499. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN],
  1500. .rpc_argp = o_arg,
  1501. .rpc_resp = o_res,
  1502. .rpc_cred = data->owner->so_cred,
  1503. };
  1504. struct rpc_task_setup task_setup_data = {
  1505. .rpc_client = server->client,
  1506. .rpc_message = &msg,
  1507. .callback_ops = &nfs4_open_ops,
  1508. .callback_data = data,
  1509. .workqueue = nfsiod_workqueue,
  1510. .flags = RPC_TASK_ASYNC,
  1511. };
  1512. int status;
  1513. nfs41_init_sequence(&o_arg->seq_args, &o_res->seq_res, 1);
  1514. kref_get(&data->kref);
  1515. data->rpc_done = 0;
  1516. data->rpc_status = 0;
  1517. data->cancelled = 0;
  1518. if (isrecover)
  1519. nfs4_set_sequence_privileged(&o_arg->seq_args);
  1520. task = rpc_run_task(&task_setup_data);
  1521. if (IS_ERR(task))
  1522. return PTR_ERR(task);
  1523. status = nfs4_wait_for_completion_rpc_task(task);
  1524. if (status != 0) {
  1525. data->cancelled = 1;
  1526. smp_wmb();
  1527. } else
  1528. status = data->rpc_status;
  1529. rpc_put_task(task);
  1530. return status;
  1531. }
  1532. static int _nfs4_recover_proc_open(struct nfs4_opendata *data)
  1533. {
  1534. struct inode *dir = data->dir->d_inode;
  1535. struct nfs_openres *o_res = &data->o_res;
  1536. int status;
  1537. status = nfs4_run_open_task(data, 1);
  1538. if (status != 0 || !data->rpc_done)
  1539. return status;
  1540. nfs_fattr_map_and_free_names(NFS_SERVER(dir), &data->f_attr);
  1541. if (o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
  1542. status = _nfs4_proc_open_confirm(data);
  1543. if (status != 0)
  1544. return status;
  1545. }
  1546. return status;
  1547. }
  1548. static int nfs4_opendata_access(struct rpc_cred *cred,
  1549. struct nfs4_opendata *opendata,
  1550. struct nfs4_state *state, fmode_t fmode,
  1551. int openflags)
  1552. {
  1553. struct nfs_access_entry cache;
  1554. u32 mask;
  1555. /* access call failed or for some reason the server doesn't
  1556. * support any access modes -- defer access call until later */
  1557. if (opendata->o_res.access_supported == 0)
  1558. return 0;
  1559. mask = 0;
  1560. /* don't check MAY_WRITE - a newly created file may not have
  1561. * write mode bits, but POSIX allows the creating process to write.
  1562. * use openflags to check for exec, because fmode won't
  1563. * always have FMODE_EXEC set when file open for exec. */
  1564. if (openflags & __FMODE_EXEC) {
  1565. /* ONLY check for exec rights */
  1566. mask = MAY_EXEC;
  1567. } else if (fmode & FMODE_READ)
  1568. mask = MAY_READ;
  1569. cache.cred = cred;
  1570. cache.jiffies = jiffies;
  1571. nfs_access_set_mask(&cache, opendata->o_res.access_result);
  1572. nfs_access_add_cache(state->inode, &cache);
  1573. if ((mask & ~cache.mask & (MAY_READ | MAY_EXEC)) == 0)
  1574. return 0;
  1575. /* even though OPEN succeeded, access is denied. Close the file */
  1576. nfs4_close_state(state, fmode);
  1577. return -EACCES;
  1578. }
  1579. /*
  1580. * Note: On error, nfs4_proc_open will free the struct nfs4_opendata
  1581. */
  1582. static int _nfs4_proc_open(struct nfs4_opendata *data)
  1583. {
  1584. struct inode *dir = data->dir->d_inode;
  1585. struct nfs_server *server = NFS_SERVER(dir);
  1586. struct nfs_openargs *o_arg = &data->o_arg;
  1587. struct nfs_openres *o_res = &data->o_res;
  1588. int status;
  1589. status = nfs4_run_open_task(data, 0);
  1590. if (!data->rpc_done)
  1591. return status;
  1592. if (status != 0) {
  1593. if (status == -NFS4ERR_BADNAME &&
  1594. !(o_arg->open_flags & O_CREAT))
  1595. return -ENOENT;
  1596. return status;
  1597. }
  1598. nfs_fattr_map_and_free_names(server, &data->f_attr);
  1599. if (o_arg->open_flags & O_CREAT)
  1600. update_changeattr(dir, &o_res->cinfo);
  1601. if ((o_res->rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) == 0)
  1602. server->caps &= ~NFS_CAP_POSIX_LOCK;
  1603. if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
  1604. status = _nfs4_proc_open_confirm(data);
  1605. if (status != 0)
  1606. return status;
  1607. }
  1608. if (!(o_res->f_attr->valid & NFS_ATTR_FATTR))
  1609. _nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr);
  1610. return 0;
  1611. }
  1612. static int nfs4_recover_expired_lease(struct nfs_server *server)
  1613. {
  1614. return nfs4_client_recover_expired_lease(server->nfs_client);
  1615. }
  1616. /*
  1617. * OPEN_EXPIRED:
  1618. * reclaim state on the server after a network partition.
  1619. * Assumes caller holds the appropriate lock
  1620. */
  1621. static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
  1622. {
  1623. struct nfs4_opendata *opendata;
  1624. int ret;
  1625. opendata = nfs4_open_recoverdata_alloc(ctx, state,
  1626. NFS4_OPEN_CLAIM_FH);
  1627. if (IS_ERR(opendata))
  1628. return PTR_ERR(opendata);
  1629. ret = nfs4_open_recover(opendata, state);
  1630. if (ret == -ESTALE)
  1631. d_drop(ctx->dentry);
  1632. nfs4_opendata_put(opendata);
  1633. return ret;
  1634. }
  1635. static int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
  1636. {
  1637. struct nfs_server *server = NFS_SERVER(state->inode);
  1638. struct nfs4_exception exception = { };
  1639. int err;
  1640. do {
  1641. err = _nfs4_open_expired(ctx, state);
  1642. if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
  1643. continue;
  1644. switch (err) {
  1645. default:
  1646. goto out;
  1647. case -NFS4ERR_GRACE:
  1648. case -NFS4ERR_DELAY:
  1649. nfs4_handle_exception(server, err, &exception);
  1650. err = 0;
  1651. }
  1652. } while (exception.retry);
  1653. out:
  1654. return err;
  1655. }
  1656. static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
  1657. {
  1658. struct nfs_open_context *ctx;
  1659. int ret;
  1660. ctx = nfs4_state_find_open_context(state);
  1661. if (IS_ERR(ctx))
  1662. return -EAGAIN;
  1663. ret = nfs4_do_open_expired(ctx, state);
  1664. put_nfs_open_context(ctx);
  1665. return ret;
  1666. }
  1667. #if defined(CONFIG_NFS_V4_1)
  1668. static void nfs41_clear_delegation_stateid(struct nfs4_state *state)
  1669. {
  1670. struct nfs_server *server = NFS_SERVER(state->inode);
  1671. nfs4_stateid *stateid = &state->stateid;
  1672. int status;
  1673. /* If a state reset has been done, test_stateid is unneeded */
  1674. if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
  1675. return;
  1676. status = nfs41_test_stateid(server, stateid);
  1677. if (status != NFS_OK) {
  1678. /* Free the stateid unless the server explicitly
  1679. * informs us the stateid is unrecognized. */
  1680. if (status != -NFS4ERR_BAD_STATEID)
  1681. nfs41_free_stateid(server, stateid);
  1682. nfs_remove_bad_delegation(state->inode);
  1683. write_seqlock(&state->seqlock);
  1684. nfs4_stateid_copy(&state->stateid, &state->open_stateid);
  1685. write_sequnlock(&state->seqlock);
  1686. clear_bit(NFS_DELEGATED_STATE, &state->flags);
  1687. }
  1688. }
  1689. /**
  1690. * nfs41_check_open_stateid - possibly free an open stateid
  1691. *
  1692. * @state: NFSv4 state for an inode
  1693. *
  1694. * Returns NFS_OK if recovery for this stateid is now finished.
  1695. * Otherwise a negative NFS4ERR value is returned.
  1696. */
  1697. static int nfs41_check_open_stateid(struct nfs4_state *state)
  1698. {
  1699. struct nfs_server *server = NFS_SERVER(state->inode);
  1700. nfs4_stateid *stateid = &state->open_stateid;
  1701. int status;
  1702. /* If a state reset has been done, test_stateid is unneeded */
  1703. if ((test_bit(NFS_O_RDONLY_STATE, &state->flags) == 0) &&
  1704. (test_bit(NFS_O_WRONLY_STATE, &state->flags) == 0) &&
  1705. (test_bit(NFS_O_RDWR_STATE, &state->flags) == 0))
  1706. return -NFS4ERR_BAD_STATEID;
  1707. status = nfs41_test_stateid(server, stateid);
  1708. if (status != NFS_OK) {
  1709. /* Free the stateid unless the server explicitly
  1710. * informs us the stateid is unrecognized. */
  1711. if (status != -NFS4ERR_BAD_STATEID)
  1712. nfs41_free_stateid(server, stateid);
  1713. clear_bit(NFS_O_RDONLY_STATE, &state->flags);
  1714. clear_bit(NFS_O_WRONLY_STATE, &state->flags);
  1715. clear_bit(NFS_O_RDWR_STATE, &state->flags);
  1716. clear_bit(NFS_OPEN_STATE, &state->flags);
  1717. }
  1718. return status;
  1719. }
  1720. static int nfs41_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
  1721. {
  1722. int status;
  1723. nfs41_clear_delegation_stateid(state);
  1724. status = nfs41_check_open_stateid(state);
  1725. if (status != NFS_OK)
  1726. status = nfs4_open_expired(sp, state);
  1727. return status;
  1728. }
  1729. #endif
  1730. /*
  1731. * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
  1732. * fields corresponding to attributes that were used to store the verifier.
  1733. * Make sure we clobber those fields in the later setattr call
  1734. */
  1735. static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct iattr *sattr)
  1736. {
  1737. if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_ACCESS) &&
  1738. !(sattr->ia_valid & ATTR_ATIME_SET))
  1739. sattr->ia_valid |= ATTR_ATIME;
  1740. if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_MODIFY) &&
  1741. !(sattr->ia_valid & ATTR_MTIME_SET))
  1742. sattr->ia_valid |= ATTR_MTIME;
  1743. }
  1744. static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
  1745. fmode_t fmode,
  1746. int flags,
  1747. struct nfs4_state **res)
  1748. {
  1749. struct nfs4_state_owner *sp = opendata->owner;
  1750. struct nfs_server *server = sp->so_server;
  1751. struct nfs4_state *state;
  1752. unsigned int seq;
  1753. int ret;
  1754. seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
  1755. ret = _nfs4_proc_open(opendata);
  1756. if (ret != 0)
  1757. goto out;
  1758. state = nfs4_opendata_to_nfs4_state(opendata);
  1759. ret = PTR_ERR(state);
  1760. if (IS_ERR(state))
  1761. goto out;
  1762. if (server->caps & NFS_CAP_POSIX_LOCK)
  1763. set_bit(NFS_STATE_POSIX_LOCKS, &state->flags);
  1764. ret = nfs4_opendata_access(sp->so_cred, opendata, state, fmode, flags);
  1765. if (ret != 0)
  1766. goto out;
  1767. if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
  1768. nfs4_schedule_stateid_recovery(server, state);
  1769. *res = state;
  1770. out:
  1771. return ret;
  1772. }
  1773. /*
  1774. * Returns a referenced nfs4_state
  1775. */
  1776. static int _nfs4_do_open(struct inode *dir,
  1777. struct dentry *dentry,
  1778. fmode_t fmode,
  1779. int flags,
  1780. struct iattr *sattr,
  1781. struct rpc_cred *cred,
  1782. struct nfs4_state **res,
  1783. struct nfs4_threshold **ctx_th)
  1784. {
  1785. struct nfs4_state_owner *sp;
  1786. struct nfs4_state *state = NULL;
  1787. struct nfs_server *server = NFS_SERVER(dir);
  1788. struct nfs4_opendata *opendata;
  1789. enum open_claim_type4 claim = NFS4_OPEN_CLAIM_NULL;
  1790. int status;
  1791. /* Protect against reboot recovery conflicts */
  1792. status = -ENOMEM;
  1793. sp = nfs4_get_state_owner(server, cred, GFP_KERNEL);
  1794. if (sp == NULL) {
  1795. dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n");
  1796. goto out_err;
  1797. }
  1798. status = nfs4_recover_expired_lease(server);
  1799. if (status != 0)
  1800. goto err_put_state_owner;
  1801. if (dentry->d_inode != NULL)
  1802. nfs4_return_incompatible_delegation(dentry->d_inode, fmode);
  1803. status = -ENOMEM;
  1804. if (dentry->d_inode)
  1805. claim = NFS4_OPEN_CLAIM_FH;
  1806. opendata = nfs4_opendata_alloc(dentry, sp, fmode, flags, sattr,
  1807. claim, GFP_KERNEL);
  1808. if (opendata == NULL)
  1809. goto err_put_state_owner;
  1810. if (ctx_th && server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) {
  1811. opendata->f_attr.mdsthreshold = pnfs_mdsthreshold_alloc();
  1812. if (!opendata->f_attr.mdsthreshold)
  1813. goto err_opendata_put;
  1814. opendata->o_arg.open_bitmap = &nfs4_pnfs_open_bitmap[0];
  1815. }
  1816. if (dentry->d_inode != NULL)
  1817. opendata->state = nfs4_get_open_state(dentry->d_inode, sp);
  1818. status = _nfs4_open_and_get_state(opendata, fmode, flags, &state);
  1819. if (status != 0)
  1820. goto err_opendata_put;
  1821. if ((opendata->o_arg.open_flags & O_EXCL) &&
  1822. (opendata->o_arg.createmode != NFS4_CREATE_GUARDED)) {
  1823. nfs4_exclusive_attrset(opendata, sattr);
  1824. nfs_fattr_init(opendata->o_res.f_attr);
  1825. status = nfs4_do_setattr(state->inode, cred,
  1826. opendata->o_res.f_attr, sattr,
  1827. state);
  1828. if (status == 0)
  1829. nfs_setattr_update_inode(state->inode, sattr);
  1830. nfs_post_op_update_inode(state->inode, opendata->o_res.f_attr);
  1831. }
  1832. if (pnfs_use_threshold(ctx_th, opendata->f_attr.mdsthreshold, server))
  1833. *ctx_th = opendata->f_attr.mdsthreshold;
  1834. else
  1835. kfree(opendata->f_attr.mdsthreshold);
  1836. opendata->f_attr.mdsthreshold = NULL;
  1837. nfs4_opendata_put(opendata);
  1838. nfs4_put_state_owner(sp);
  1839. *res = state;
  1840. return 0;
  1841. err_opendata_put:
  1842. kfree(opendata->f_attr.mdsthreshold);
  1843. nfs4_opendata_put(opendata);
  1844. err_put_state_owner:
  1845. nfs4_put_state_owner(sp);
  1846. out_err:
  1847. *res = NULL;
  1848. return status;
  1849. }
  1850. static struct nfs4_state *nfs4_do_open(struct inode *dir,
  1851. struct dentry *dentry,
  1852. fmode_t fmode,
  1853. int flags,
  1854. struct iattr *sattr,
  1855. struct rpc_cred *cred,
  1856. struct nfs4_threshold **ctx_th)
  1857. {
  1858. struct nfs_server *server = NFS_SERVER(dir);
  1859. struct nfs4_exception exception = { };
  1860. struct nfs4_state *res;
  1861. int status;
  1862. fmode &= FMODE_READ|FMODE_WRITE|FMODE_EXEC;
  1863. do {
  1864. status = _nfs4_do_open(dir, dentry, fmode, flags, sattr, cred,
  1865. &res, ctx_th);
  1866. if (status == 0)
  1867. break;
  1868. /* NOTE: BAD_SEQID means the server and client disagree about the
  1869. * book-keeping w.r.t. state-changing operations
  1870. * (OPEN/CLOSE/LOCK/LOCKU...)
  1871. * It is actually a sign of a bug on the client or on the server.
  1872. *
  1873. * If we receive a BAD_SEQID error in the particular case of
  1874. * doing an OPEN, we assume that nfs_increment_open_seqid() will
  1875. * have unhashed the old state_owner for us, and that we can
  1876. * therefore safely retry using a new one. We should still warn
  1877. * the user though...
  1878. */
  1879. if (status == -NFS4ERR_BAD_SEQID) {
  1880. pr_warn_ratelimited("NFS: v4 server %s "
  1881. " returned a bad sequence-id error!\n",
  1882. NFS_SERVER(dir)->nfs_client->cl_hostname);
  1883. exception.retry = 1;
  1884. continue;
  1885. }
  1886. /*
  1887. * BAD_STATEID on OPEN means that the server cancelled our
  1888. * state before it received the OPEN_CONFIRM.
  1889. * Recover by retrying the request as per the discussion
  1890. * on Page 181 of RFC3530.
  1891. */
  1892. if (status == -NFS4ERR_BAD_STATEID) {
  1893. exception.retry = 1;
  1894. continue;
  1895. }
  1896. if (status == -EAGAIN) {
  1897. /* We must have found a delegation */
  1898. exception.retry = 1;
  1899. continue;
  1900. }
  1901. if (nfs4_clear_cap_atomic_open_v1(server, status, &exception))
  1902. continue;
  1903. res = ERR_PTR(nfs4_handle_exception(server,
  1904. status, &exception));
  1905. } while (exception.retry);
  1906. return res;
  1907. }
  1908. static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
  1909. struct nfs_fattr *fattr, struct iattr *sattr,
  1910. struct nfs4_state *state)
  1911. {
  1912. struct nfs_server *server = NFS_SERVER(inode);
  1913. struct nfs_setattrargs arg = {
  1914. .fh = NFS_FH(inode),
  1915. .iap = sattr,
  1916. .server = server,
  1917. .bitmask = server->attr_bitmask,
  1918. };
  1919. struct nfs_setattrres res = {
  1920. .fattr = fattr,
  1921. .server = server,
  1922. };
  1923. struct rpc_message msg = {
  1924. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
  1925. .rpc_argp = &arg,
  1926. .rpc_resp = &res,
  1927. .rpc_cred = cred,
  1928. };
  1929. unsigned long timestamp = jiffies;
  1930. int status;
  1931. nfs_fattr_init(fattr);
  1932. if (state != NULL && nfs4_valid_open_stateid(state)) {
  1933. struct nfs_lockowner lockowner = {
  1934. .l_owner = current->files,
  1935. .l_pid = current->tgid,
  1936. };
  1937. nfs4_select_rw_stateid(&arg.stateid, state, FMODE_WRITE,
  1938. &lockowner);
  1939. } else if (nfs4_copy_delegation_stateid(&arg.stateid, inode,
  1940. FMODE_WRITE)) {
  1941. /* Use that stateid */
  1942. } else
  1943. nfs4_stateid_copy(&arg.stateid, &zero_stateid);
  1944. status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
  1945. if (status == 0 && state != NULL)
  1946. renew_lease(server, timestamp);
  1947. return status;
  1948. }
  1949. static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
  1950. struct nfs_fattr *fattr, struct iattr *sattr,
  1951. struct nfs4_state *state)
  1952. {
  1953. struct nfs_server *server = NFS_SERVER(inode);
  1954. struct nfs4_exception exception = {
  1955. .state = state,
  1956. .inode = inode,
  1957. };
  1958. int err;
  1959. do {
  1960. err = _nfs4_do_setattr(inode, cred, fattr, sattr, state);
  1961. switch (err) {
  1962. case -NFS4ERR_OPENMODE:
  1963. if (state && !(state->state & FMODE_WRITE)) {
  1964. err = -EBADF;
  1965. if (sattr->ia_valid & ATTR_OPEN)
  1966. err = -EACCES;
  1967. goto out;
  1968. }
  1969. }
  1970. err = nfs4_handle_exception(server, err, &exception);
  1971. } while (exception.retry);
  1972. out:
  1973. return err;
  1974. }
  1975. struct nfs4_closedata {
  1976. struct inode *inode;
  1977. struct nfs4_state *state;
  1978. struct nfs_closeargs arg;
  1979. struct nfs_closeres res;
  1980. struct nfs_fattr fattr;
  1981. unsigned long timestamp;
  1982. bool roc;
  1983. u32 roc_barrier;
  1984. };
  1985. static void nfs4_free_closedata(void *data)
  1986. {
  1987. struct nfs4_closedata *calldata = data;
  1988. struct nfs4_state_owner *sp = calldata->state->owner;
  1989. struct super_block *sb = calldata->state->inode->i_sb;
  1990. if (calldata->roc)
  1991. pnfs_roc_release(calldata->state->inode);
  1992. nfs4_put_open_state(calldata->state);
  1993. nfs_free_seqid(calldata->arg.seqid);
  1994. nfs4_put_state_owner(sp);
  1995. nfs_sb_deactive(sb);
  1996. kfree(calldata);
  1997. }
  1998. static void nfs4_close_clear_stateid_flags(struct nfs4_state *state,
  1999. fmode_t fmode)
  2000. {
  2001. spin_lock(&state->owner->so_lock);
  2002. clear_bit(NFS_O_RDWR_STATE, &state->flags);
  2003. switch (fmode & (FMODE_READ|FMODE_WRITE)) {
  2004. case FMODE_WRITE:
  2005. clear_bit(NFS_O_RDONLY_STATE, &state->flags);
  2006. break;
  2007. case FMODE_READ:
  2008. clear_bit(NFS_O_WRONLY_STATE, &state->flags);
  2009. break;
  2010. case 0:
  2011. clear_bit(NFS_O_RDONLY_STATE, &state->flags);
  2012. clear_bit(NFS_O_WRONLY_STATE, &state->flags);
  2013. clear_bit(NFS_OPEN_STATE, &state->flags);
  2014. }
  2015. spin_unlock(&state->owner->so_lock);
  2016. }
  2017. static void nfs4_close_done(struct rpc_task *task, void *data)
  2018. {
  2019. struct nfs4_closedata *calldata = data;
  2020. struct nfs4_state *state = calldata->state;
  2021. struct nfs_server *server = NFS_SERVER(calldata->inode);
  2022. dprintk("%s: begin!\n", __func__);
  2023. if (!nfs4_sequence_done(task, &calldata->res.seq_res))
  2024. return;
  2025. /* hmm. we are done with the inode, and in the process of freeing
  2026. * the state_owner. we keep this around to process errors
  2027. */
  2028. switch (task->tk_status) {
  2029. case 0:
  2030. if (calldata->roc)
  2031. pnfs_roc_set_barrier(state->inode,
  2032. calldata->roc_barrier);
  2033. nfs_set_open_stateid(state, &calldata->res.stateid, 0);
  2034. renew_lease(server, calldata->timestamp);
  2035. nfs4_close_clear_stateid_flags(state,
  2036. calldata->arg.fmode);
  2037. break;
  2038. case -NFS4ERR_STALE_STATEID:
  2039. case -NFS4ERR_OLD_STATEID:
  2040. case -NFS4ERR_BAD_STATEID:
  2041. case -NFS4ERR_EXPIRED:
  2042. if (calldata->arg.fmode == 0)
  2043. break;
  2044. default:
  2045. if (nfs4_async_handle_error(task, server, state) == -EAGAIN)
  2046. rpc_restart_call_prepare(task);
  2047. }
  2048. nfs_release_seqid(calldata->arg.seqid);
  2049. nfs_refresh_inode(calldata->inode, calldata->res.fattr);
  2050. dprintk("%s: done, ret = %d!\n", __func__, task->tk_status);
  2051. }
  2052. static void nfs4_close_prepare(struct rpc_task *task, void *data)
  2053. {
  2054. struct nfs4_closedata *calldata = data;
  2055. struct nfs4_state *state = calldata->state;
  2056. struct inode *inode = calldata->inode;
  2057. int call_close = 0;
  2058. dprintk("%s: begin!\n", __func__);
  2059. if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
  2060. goto out_wait;
  2061. task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];
  2062. calldata->arg.fmode = FMODE_READ|FMODE_WRITE;
  2063. spin_lock(&state->owner->so_lock);
  2064. /* Calculate the change in open mode */
  2065. if (state->n_rdwr == 0) {
  2066. if (state->n_rdonly == 0) {
  2067. call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags);
  2068. call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
  2069. calldata->arg.fmode &= ~FMODE_READ;
  2070. }
  2071. if (state->n_wronly == 0) {
  2072. call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags);
  2073. call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
  2074. calldata->arg.fmode &= ~FMODE_WRITE;
  2075. }
  2076. }
  2077. if (!nfs4_valid_open_stateid(state))
  2078. call_close = 0;
  2079. spin_unlock(&state->owner->so_lock);
  2080. if (!call_close) {
  2081. /* Note: exit _without_ calling nfs4_close_done */
  2082. goto out_no_action;
  2083. }
  2084. if (calldata->arg.fmode == 0) {
  2085. task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE];
  2086. if (calldata->roc &&
  2087. pnfs_roc_drain(inode, &calldata->roc_barrier, task)) {
  2088. nfs_release_seqid(calldata->arg.seqid);
  2089. goto out_wait;
  2090. }
  2091. }
  2092. nfs_fattr_init(calldata->res.fattr);
  2093. calldata->timestamp = jiffies;
  2094. if (nfs4_setup_sequence(NFS_SERVER(inode),
  2095. &calldata->arg.seq_args,
  2096. &calldata->res.seq_res,
  2097. task) != 0)
  2098. nfs_release_seqid(calldata->arg.seqid);
  2099. dprintk("%s: done!\n", __func__);
  2100. return;
  2101. out_no_action:
  2102. task->tk_action = NULL;
  2103. out_wait:
  2104. nfs4_sequence_done(task, &calldata->res.seq_res);
  2105. }
  2106. static const struct rpc_call_ops nfs4_close_ops = {
  2107. .rpc_call_prepare = nfs4_close_prepare,
  2108. .rpc_call_done = nfs4_close_done,
  2109. .rpc_release = nfs4_free_closedata,
  2110. };
  2111. /*
  2112. * It is possible for data to be read/written from a mem-mapped file
  2113. * after the sys_close call (which hits the vfs layer as a flush).
  2114. * This means that we can't safely call nfsv4 close on a file until
  2115. * the inode is cleared. This in turn means that we are not good
  2116. * NFSv4 citizens - we do not indicate to the server to update the file's
  2117. * share state even when we are done with one of the three share
  2118. * stateid's in the inode.
  2119. *
  2120. * NOTE: Caller must be holding the sp->so_owner semaphore!
  2121. */
  2122. int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait)
  2123. {
  2124. struct nfs_server *server = NFS_SERVER(state->inode);
  2125. struct nfs4_closedata *calldata;
  2126. struct nfs4_state_owner *sp = state->owner;
  2127. struct rpc_task *task;
  2128. struct rpc_message msg = {
  2129. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE],
  2130. .rpc_cred = state->owner->so_cred,
  2131. };
  2132. struct rpc_task_setup task_setup_data = {
  2133. .rpc_client = server->client,
  2134. .rpc_message = &msg,
  2135. .callback_ops = &nfs4_close_ops,
  2136. .workqueue = nfsiod_workqueue,
  2137. .flags = RPC_TASK_ASYNC,
  2138. };
  2139. int status = -ENOMEM;
  2140. calldata = kzalloc(sizeof(*calldata), gfp_mask);
  2141. if (calldata == NULL)
  2142. goto out;
  2143. nfs41_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 1);
  2144. calldata->inode = state->inode;
  2145. calldata->state = state;
  2146. calldata->arg.fh = NFS_FH(state->inode);
  2147. calldata->arg.stateid = &state->open_stateid;
  2148. /* Serialization for the sequence id */
  2149. calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid, gfp_mask);
  2150. if (calldata->arg.seqid == NULL)
  2151. goto out_free_calldata;
  2152. calldata->arg.fmode = 0;
  2153. calldata->arg.bitmask = server->cache_consistency_bitmask;
  2154. calldata->res.fattr = &calldata->fattr;
  2155. calldata->res.seqid = calldata->arg.seqid;
  2156. calldata->res.server = server;
  2157. calldata->roc = pnfs_roc(state->inode);
  2158. nfs_sb_active(calldata->inode->i_sb);
  2159. msg.rpc_argp = &calldata->arg;
  2160. msg.rpc_resp = &calldata->res;
  2161. task_setup_data.callback_data = calldata;
  2162. task = rpc_run_task(&task_setup_data);
  2163. if (IS_ERR(task))
  2164. return PTR_ERR(task);
  2165. status = 0;
  2166. if (wait)
  2167. status = rpc_wait_for_completion_task(task);
  2168. rpc_put_task(task);
  2169. return status;
  2170. out_free_calldata:
  2171. kfree(calldata);
  2172. out:
  2173. nfs4_put_open_state(state);
  2174. nfs4_put_state_owner(sp);
  2175. return status;
  2176. }
  2177. static struct inode *
  2178. nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx, int open_flags, struct iattr *attr)
  2179. {
  2180. struct nfs4_state *state;
  2181. /* Protect against concurrent sillydeletes */
  2182. state = nfs4_do_open(dir, ctx->dentry, ctx->mode, open_flags, attr,
  2183. ctx->cred, &ctx->mdsthreshold);
  2184. if (IS_ERR(state))
  2185. return ERR_CAST(state);
  2186. ctx->state = state;
  2187. return igrab(state->inode);
  2188. }
  2189. static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync)
  2190. {
  2191. if (ctx->state == NULL)
  2192. return;
  2193. if (is_sync)
  2194. nfs4_close_sync(ctx->state, ctx->mode);
  2195. else
  2196. nfs4_close_state(ctx->state, ctx->mode);
  2197. }
  2198. static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
  2199. {
  2200. struct nfs4_server_caps_arg args = {
  2201. .fhandle = fhandle,
  2202. };
  2203. struct nfs4_server_caps_res res = {};
  2204. struct rpc_message msg = {
  2205. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS],
  2206. .rpc_argp = &args,
  2207. .rpc_resp = &res,
  2208. };
  2209. int status;
  2210. status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
  2211. if (status == 0) {
  2212. memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask));
  2213. server->caps &= ~(NFS_CAP_ACLS|NFS_CAP_HARDLINKS|
  2214. NFS_CAP_SYMLINKS|NFS_CAP_FILEID|
  2215. NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|
  2216. NFS_CAP_OWNER_GROUP|NFS_CAP_ATIME|
  2217. NFS_CAP_CTIME|NFS_CAP_MTIME);
  2218. if (res.attr_bitmask[0] & FATTR4_WORD0_ACL)
  2219. server->caps |= NFS_CAP_ACLS;
  2220. if (res.has_links != 0)
  2221. server->caps |= NFS_CAP_HARDLINKS;
  2222. if (res.has_symlinks != 0)
  2223. server->caps |= NFS_CAP_SYMLINKS;
  2224. if (res.attr_bitmask[0] & FATTR4_WORD0_FILEID)
  2225. server->caps |= NFS_CAP_FILEID;
  2226. if (res.attr_bitmask[1] & FATTR4_WORD1_MODE)
  2227. server->caps |= NFS_CAP_MODE;
  2228. if (res.attr_bitmask[1] & FATTR4_WORD1_NUMLINKS)
  2229. server->caps |= NFS_CAP_NLINK;
  2230. if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER)
  2231. server->caps |= NFS_CAP_OWNER;
  2232. if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER_GROUP)
  2233. server->caps |= NFS_CAP_OWNER_GROUP;
  2234. if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_ACCESS)
  2235. server->caps |= NFS_CAP_ATIME;
  2236. if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_METADATA)
  2237. server->caps |= NFS_CAP_CTIME;
  2238. if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY)
  2239. server->caps |= NFS_CAP_MTIME;
  2240. memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask));
  2241. server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE;
  2242. server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;
  2243. server->acl_bitmask = res.acl_bitmask;
  2244. server->fh_expire_type = res.fh_expire_type;
  2245. }
  2246. return status;
  2247. }
  2248. int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
  2249. {
  2250. struct nfs4_exception exception = { };
  2251. int err;
  2252. do {
  2253. err = nfs4_handle_exception(server,
  2254. _nfs4_server_capabilities(server, fhandle),
  2255. &exception);
  2256. } while (exception.retry);
  2257. return err;
  2258. }
  2259. static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
  2260. struct nfs_fsinfo *info)
  2261. {
  2262. struct nfs4_lookup_root_arg args = {
  2263. .bitmask = nfs4_fattr_bitmap,
  2264. };
  2265. struct nfs4_lookup_res res = {
  2266. .server = server,
  2267. .fattr = info->fattr,
  2268. .fh = fhandle,
  2269. };
  2270. struct rpc_message msg = {
  2271. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT],
  2272. .rpc_argp = &args,
  2273. .rpc_resp = &res,
  2274. };
  2275. nfs_fattr_init(info->fattr);
  2276. return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
  2277. }
  2278. static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
  2279. struct nfs_fsinfo *info)
  2280. {
  2281. struct nfs4_exception exception = { };
  2282. int err;
  2283. do {
  2284. err = _nfs4_lookup_root(server, fhandle, info);
  2285. switch (err) {
  2286. case 0:
  2287. case -NFS4ERR_WRONGSEC:
  2288. goto out;
  2289. default:
  2290. err = nfs4_handle_exception(server, err, &exception);
  2291. }
  2292. } while (exception.retry);
  2293. out:
  2294. return err;
  2295. }
  2296. static int nfs4_lookup_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
  2297. struct nfs_fsinfo *info, rpc_authflavor_t flavor)
  2298. {
  2299. struct rpc_auth *auth;
  2300. int ret;
  2301. auth = rpcauth_create(flavor, server->client);
  2302. if (IS_ERR(auth)) {
  2303. ret = -EIO;
  2304. goto out;
  2305. }
  2306. ret = nfs4_lookup_root(server, fhandle, info);
  2307. out:
  2308. return ret;
  2309. }
  2310. static int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
  2311. struct nfs_fsinfo *info)
  2312. {
  2313. int i, len, status = 0;
  2314. rpc_authflavor_t flav_array[NFS_MAX_SECFLAVORS];
  2315. len = rpcauth_list_flavors(flav_array, ARRAY_SIZE(flav_array));
  2316. if (len < 0)
  2317. return len;
  2318. for (i = 0; i < len; i++) {
  2319. /* AUTH_UNIX is the default flavor if none was specified,
  2320. * thus has already been tried. */
  2321. if (flav_array[i] == RPC_AUTH_UNIX)
  2322. continue;
  2323. status = nfs4_lookup_root_sec(server, fhandle, info, flav_array[i]);
  2324. if (status == -NFS4ERR_WRONGSEC || status == -EACCES)
  2325. continue;
  2326. break;
  2327. }
  2328. /*
  2329. * -EACCESS could mean that the user doesn't have correct permissions
  2330. * to access the mount. It could also mean that we tried to mount
  2331. * with a gss auth flavor, but rpc.gssd isn't running. Either way,
  2332. * existing mount programs don't handle -EACCES very well so it should
  2333. * be mapped to -EPERM instead.
  2334. */
  2335. if (status == -EACCES)
  2336. status = -EPERM;
  2337. return status;
  2338. }
  2339. /*
  2340. * get the file handle for the "/" directory on the server
  2341. */
  2342. int nfs4_proc_get_rootfh(struct nfs_server *server, struct nfs_fh *fhandle,
  2343. struct nfs_fsinfo *info)
  2344. {
  2345. int minor_version = server->nfs_client->cl_minorversion;
  2346. int status = nfs4_lookup_root(server, fhandle, info);
  2347. if ((status == -NFS4ERR_WRONGSEC) && !(server->flags & NFS_MOUNT_SECFLAVOUR))
  2348. /*
  2349. * A status of -NFS4ERR_WRONGSEC will be mapped to -EPERM
  2350. * by nfs4_map_errors() as this function exits.
  2351. */
  2352. status = nfs_v4_minor_ops[minor_version]->find_root_sec(server, fhandle, info);
  2353. if (status == 0)
  2354. status = nfs4_server_capabilities(server, fhandle);
  2355. if (status == 0)
  2356. status = nfs4_do_fsinfo(server, fhandle, info);
  2357. return nfs4_map_errors(status);
  2358. }
  2359. static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh,
  2360. struct nfs_fsinfo *info)
  2361. {
  2362. int error;
  2363. struct nfs_fattr *fattr = info->fattr;
  2364. error = nfs4_server_capabilities(server, mntfh);
  2365. if (error < 0) {
  2366. dprintk("nfs4_get_root: getcaps error = %d\n", -error);
  2367. return error;
  2368. }
  2369. error = nfs4_proc_getattr(server, mntfh, fattr);
  2370. if (error < 0) {
  2371. dprintk("nfs4_get_root: getattr error = %d\n", -error);
  2372. return error;
  2373. }
  2374. if (fattr->valid & NFS_ATTR_FATTR_FSID &&
  2375. !nfs_fsid_equal(&server->fsid, &fattr->fsid))
  2376. memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
  2377. return error;
  2378. }
  2379. /*
  2380. * Get locations and (maybe) other attributes of a referral.
  2381. * Note that we'll actually follow the referral later when
  2382. * we detect fsid mismatch in inode revalidation
  2383. */
  2384. static int nfs4_get_referral(struct rpc_clnt *client, struct inode *dir,
  2385. const struct qstr *name, struct nfs_fattr *fattr,
  2386. struct nfs_fh *fhandle)
  2387. {
  2388. int status = -ENOMEM;
  2389. struct page *page = NULL;
  2390. struct nfs4_fs_locations *locations = NULL;
  2391. page = alloc_page(GFP_KERNEL);
  2392. if (page == NULL)
  2393. goto out;
  2394. locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
  2395. if (locations == NULL)
  2396. goto out;
  2397. status = nfs4_proc_fs_locations(client, dir, name, locations, page);
  2398. if (status != 0)
  2399. goto out;
  2400. /* Make sure server returned a different fsid for the referral */
  2401. if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) {
  2402. dprintk("%s: server did not return a different fsid for"
  2403. " a referral at %s\n", __func__, name->name);
  2404. status = -EIO;
  2405. goto out;
  2406. }
  2407. /* Fixup attributes for the nfs_lookup() call to nfs_fhget() */
  2408. nfs_fixup_referral_attributes(&locations->fattr);
  2409. /* replace the lookup nfs_fattr with the locations nfs_fattr */
  2410. memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr));
  2411. memset(fhandle, 0, sizeof(struct nfs_fh));
  2412. out:
  2413. if (page)
  2414. __free_page(page);
  2415. kfree(locations);
  2416. return status;
  2417. }
  2418. static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
  2419. {
  2420. struct nfs4_getattr_arg args = {
  2421. .fh = fhandle,
  2422. .bitmask = server->attr_bitmask,
  2423. };
  2424. struct nfs4_getattr_res res = {
  2425. .fattr = fattr,
  2426. .server = server,
  2427. };
  2428. struct rpc_message msg = {
  2429. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
  2430. .rpc_argp = &args,
  2431. .rpc_resp = &res,
  2432. };
  2433. nfs_fattr_init(fattr);
  2434. return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
  2435. }
  2436. static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
  2437. {
  2438. struct nfs4_exception exception = { };
  2439. int err;
  2440. do {
  2441. err = nfs4_handle_exception(server,
  2442. _nfs4_proc_getattr(server, fhandle, fattr),
  2443. &exception);
  2444. } while (exception.retry);
  2445. return err;
  2446. }
  2447. /*
  2448. * The file is not closed if it is opened due to the a request to change
  2449. * the size of the file. The open call will not be needed once the
  2450. * VFS layer lookup-intents are implemented.
  2451. *
  2452. * Close is called when the inode is destroyed.
  2453. * If we haven't opened the file for O_WRONLY, we
  2454. * need to in the size_change case to obtain a stateid.
  2455. *
  2456. * Got race?
  2457. * Because OPEN is always done by name in nfsv4, it is
  2458. * possible that we opened a different file by the same
  2459. * name. We can recognize this race condition, but we
  2460. * can't do anything about it besides returning an error.
  2461. *
  2462. * This will be fixed with VFS changes (lookup-intent).
  2463. */
  2464. static int
  2465. nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
  2466. struct iattr *sattr)
  2467. {
  2468. struct inode *inode = dentry->d_inode;
  2469. struct rpc_cred *cred = NULL;
  2470. struct nfs4_state *state = NULL;
  2471. int status;
  2472. if (pnfs_ld_layoutret_on_setattr(inode))
  2473. pnfs_commit_and_return_layout(inode);
  2474. nfs_fattr_init(fattr);
  2475. /* Deal with open(O_TRUNC) */
  2476. if (sattr->ia_valid & ATTR_OPEN)
  2477. sattr->ia_valid &= ~(ATTR_MTIME|ATTR_CTIME|ATTR_OPEN);
  2478. /* Optimization: if the end result is no change, don't RPC */
  2479. if ((sattr->ia_valid & ~(ATTR_FILE)) == 0)
  2480. return 0;
  2481. /* Search for an existing open(O_WRITE) file */
  2482. if (sattr->ia_valid & ATTR_FILE) {
  2483. struct nfs_open_context *ctx;
  2484. ctx = nfs_file_open_context(sattr->ia_file);
  2485. if (ctx) {
  2486. cred = ctx->cred;
  2487. state = ctx->state;
  2488. }
  2489. }
  2490. status = nfs4_do_setattr(inode, cred, fattr, sattr, state);
  2491. if (status == 0)
  2492. nfs_setattr_update_inode(inode, sattr);
  2493. return status;
  2494. }
  2495. static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
  2496. const struct qstr *name, struct nfs_fh *fhandle,
  2497. struct nfs_fattr *fattr)
  2498. {
  2499. struct nfs_server *server = NFS_SERVER(dir);
  2500. int status;
  2501. struct nfs4_lookup_arg args = {
  2502. .bitmask = server->attr_bitmask,
  2503. .dir_fh = NFS_FH(dir),
  2504. .name = name,
  2505. };
  2506. struct nfs4_lookup_res res = {
  2507. .server = server,
  2508. .fattr = fattr,
  2509. .fh = fhandle,
  2510. };
  2511. struct rpc_message msg = {
  2512. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP],
  2513. .rpc_argp = &args,
  2514. .rpc_resp = &res,
  2515. };
  2516. nfs_fattr_init(fattr);
  2517. dprintk("NFS call lookup %s\n", name->name);
  2518. status = nfs4_call_sync(clnt, server, &msg, &args.seq_args, &res.seq_res, 0);
  2519. dprintk("NFS reply lookup: %d\n", status);
  2520. return status;
  2521. }
  2522. static void nfs_fixup_secinfo_attributes(struct nfs_fattr *fattr)
  2523. {
  2524. fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
  2525. NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_MOUNTPOINT;
  2526. fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
  2527. fattr->nlink = 2;
  2528. }
  2529. static int nfs4_proc_lookup_common(struct rpc_clnt **clnt, struct inode *dir,
  2530. struct qstr *name, struct nfs_fh *fhandle,
  2531. struct nfs_fattr *fattr)
  2532. {
  2533. struct nfs4_exception exception = { };
  2534. struct rpc_clnt *client = *clnt;
  2535. int err;
  2536. do {
  2537. err = _nfs4_proc_lookup(client, dir, name, fhandle, fattr);
  2538. switch (err) {
  2539. case -NFS4ERR_BADNAME:
  2540. err = -ENOENT;
  2541. goto out;
  2542. case -NFS4ERR_MOVED:
  2543. err = nfs4_get_referral(client, dir, name, fattr, fhandle);
  2544. goto out;
  2545. case -NFS4ERR_WRONGSEC:
  2546. err = -EPERM;
  2547. if (client != *clnt)
  2548. goto out;
  2549. client = nfs4_create_sec_client(client, dir, name);
  2550. if (IS_ERR(client))
  2551. return PTR_ERR(client);
  2552. exception.retry = 1;
  2553. break;
  2554. default:
  2555. err = nfs4_handle_exception(NFS_SERVER(dir), err, &exception);
  2556. }
  2557. } while (exception.retry);
  2558. out:
  2559. if (err == 0)
  2560. *clnt = client;
  2561. else if (client != *clnt)
  2562. rpc_shutdown_client(client);
  2563. return err;
  2564. }
  2565. static int nfs4_proc_lookup(struct inode *dir, struct qstr *name,
  2566. struct nfs_fh *fhandle, struct nfs_fattr *fattr)
  2567. {
  2568. int status;
  2569. struct rpc_clnt *client = NFS_CLIENT(dir);
  2570. status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr);
  2571. if (client != NFS_CLIENT(dir)) {
  2572. rpc_shutdown_client(client);
  2573. nfs_fixup_secinfo_attributes(fattr);
  2574. }
  2575. return status;
  2576. }
  2577. struct rpc_clnt *
  2578. nfs4_proc_lookup_mountpoint(struct inode *dir, struct qstr *name,
  2579. struct nfs_fh *fhandle, struct nfs_fattr *fattr)
  2580. {
  2581. int status;
  2582. struct rpc_clnt *client = rpc_clone_client(NFS_CLIENT(dir));
  2583. status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr);
  2584. if (status < 0) {
  2585. rpc_shutdown_client(client);
  2586. return ERR_PTR(status);
  2587. }
  2588. return client;
  2589. }
  2590. static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
  2591. {
  2592. struct nfs_server *server = NFS_SERVER(inode);
  2593. struct nfs4_accessargs args = {
  2594. .fh = NFS_FH(inode),
  2595. .bitmask = server->cache_consistency_bitmask,
  2596. };
  2597. struct nfs4_accessres res = {
  2598. .server = server,
  2599. };
  2600. struct rpc_message msg = {
  2601. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS],
  2602. .rpc_argp = &args,
  2603. .rpc_resp = &res,
  2604. .rpc_cred = entry->cred,
  2605. };
  2606. int mode = entry->mask;
  2607. int status;
  2608. /*
  2609. * Determine which access bits we want to ask for...
  2610. */
  2611. if (mode & MAY_READ)
  2612. args.access |= NFS4_ACCESS_READ;
  2613. if (S_ISDIR(inode->i_mode)) {
  2614. if (mode & MAY_WRITE)
  2615. args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE;
  2616. if (mode & MAY_EXEC)
  2617. args.access |= NFS4_ACCESS_LOOKUP;
  2618. } else {
  2619. if (mode & MAY_WRITE)
  2620. args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND;
  2621. if (mode & MAY_EXEC)
  2622. args.access |= NFS4_ACCESS_EXECUTE;
  2623. }
  2624. res.fattr = nfs_alloc_fattr();
  2625. if (res.fattr == NULL)
  2626. return -ENOMEM;
  2627. status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
  2628. if (!status) {
  2629. nfs_access_set_mask(entry, res.access);
  2630. nfs_refresh_inode(inode, res.fattr);
  2631. }
  2632. nfs_free_fattr(res.fattr);
  2633. return status;
  2634. }
  2635. static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
  2636. {
  2637. struct nfs4_exception exception = { };
  2638. int err;
  2639. do {
  2640. err = nfs4_handle_exception(NFS_SERVER(inode),
  2641. _nfs4_proc_access(inode, entry),
  2642. &exception);
  2643. } while (exception.retry);
  2644. return err;
  2645. }
  2646. /*
  2647. * TODO: For the time being, we don't try to get any attributes
  2648. * along with any of the zero-copy operations READ, READDIR,
  2649. * READLINK, WRITE.
  2650. *
  2651. * In the case of the first three, we want to put the GETATTR
  2652. * after the read-type operation -- this is because it is hard
  2653. * to predict the length of a GETATTR response in v4, and thus
  2654. * align the READ data correctly. This means that the GETATTR
  2655. * may end up partially falling into the page cache, and we should
  2656. * shift it into the 'tail' of the xdr_buf before processing.
  2657. * To do this efficiently, we need to know the total length
  2658. * of data received, which doesn't seem to be available outside
  2659. * of the RPC layer.
  2660. *
  2661. * In the case of WRITE, we also want to put the GETATTR after
  2662. * the operation -- in this case because we want to make sure
  2663. * we get the post-operation mtime and size.
  2664. *
  2665. * Both of these changes to the XDR layer would in fact be quite
  2666. * minor, but I decided to leave them for a subsequent patch.
  2667. */
  2668. static int _nfs4_proc_readlink(struct inode *inode, struct page *page,
  2669. unsigned int pgbase, unsigned int pglen)
  2670. {
  2671. struct nfs4_readlink args = {
  2672. .fh = NFS_FH(inode),
  2673. .pgbase = pgbase,
  2674. .pglen = pglen,
  2675. .pages = &page,
  2676. };
  2677. struct nfs4_readlink_res res;
  2678. struct rpc_message msg = {
  2679. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK],
  2680. .rpc_argp = &args,
  2681. .rpc_resp = &res,
  2682. };
  2683. return nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq_res, 0);
  2684. }
  2685. static int nfs4_proc_readlink(struct inode *inode, struct page *page,
  2686. unsigned int pgbase, unsigned int pglen)
  2687. {
  2688. struct nfs4_exception exception = { };
  2689. int err;
  2690. do {
  2691. err = nfs4_handle_exception(NFS_SERVER(inode),
  2692. _nfs4_proc_readlink(inode, page, pgbase, pglen),
  2693. &exception);
  2694. } while (exception.retry);
  2695. return err;
  2696. }
  2697. /*
  2698. * This is just for mknod. open(O_CREAT) will always do ->open_context().
  2699. */
  2700. static int
  2701. nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
  2702. int flags)
  2703. {
  2704. struct nfs_open_context *ctx;
  2705. struct nfs4_state *state;
  2706. int status = 0;
  2707. ctx = alloc_nfs_open_context(dentry, FMODE_READ);
  2708. if (IS_ERR(ctx))
  2709. return PTR_ERR(ctx);
  2710. sattr->ia_mode &= ~current_umask();
  2711. state = nfs4_do_open(dir, dentry, ctx->mode,
  2712. flags, sattr, ctx->cred,
  2713. &ctx->mdsthreshold);
  2714. d_drop(dentry);
  2715. if (IS_ERR(state)) {
  2716. status = PTR_ERR(state);
  2717. goto out;
  2718. }
  2719. d_add(dentry, igrab(state->inode));
  2720. nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
  2721. ctx->state = state;
  2722. out:
  2723. put_nfs_open_context(ctx);
  2724. return status;
  2725. }
  2726. static int _nfs4_proc_remove(struct inode *dir, struct qstr *name)
  2727. {
  2728. struct nfs_server *server = NFS_SERVER(dir);
  2729. struct nfs_removeargs args = {
  2730. .fh = NFS_FH(dir),
  2731. .name = *name,
  2732. };
  2733. struct nfs_removeres res = {
  2734. .server = server,
  2735. };
  2736. struct rpc_message msg = {
  2737. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE],
  2738. .rpc_argp = &args,
  2739. .rpc_resp = &res,
  2740. };
  2741. int status;
  2742. status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);
  2743. if (status == 0)
  2744. update_changeattr(dir, &res.cinfo);
  2745. return status;
  2746. }
  2747. static int nfs4_proc_remove(struct inode *dir, struct qstr *name)
  2748. {
  2749. struct nfs4_exception exception = { };
  2750. int err;
  2751. do {
  2752. err = nfs4_handle_exception(NFS_SERVER(dir),
  2753. _nfs4_proc_remove(dir, name),
  2754. &exception);
  2755. } while (exception.retry);
  2756. return err;
  2757. }
  2758. static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
  2759. {
  2760. struct nfs_server *server = NFS_SERVER(dir);
  2761. struct nfs_removeargs *args = msg->rpc_argp;
  2762. struct nfs_removeres *res = msg->rpc_resp;
  2763. res->server = server;
  2764. msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];
  2765. nfs41_init_sequence(&args->seq_args, &res->seq_res, 1);
  2766. }
  2767. static void nfs4_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
  2768. {
  2769. nfs4_setup_sequence(NFS_SERVER(data->dir),
  2770. &data->args.seq_args,
  2771. &data->res.seq_res,
  2772. task);
  2773. }
  2774. static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)
  2775. {
  2776. struct nfs_removeres *res = task->tk_msg.rpc_resp;
  2777. if (!nfs4_sequence_done(task, &res->seq_res))
  2778. return 0;
  2779. if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN)
  2780. return 0;
  2781. update_changeattr(dir, &res->cinfo);
  2782. return 1;
  2783. }
  2784. static void nfs4_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
  2785. {
  2786. struct nfs_server *server = NFS_SERVER(dir);
  2787. struct nfs_renameargs *arg = msg->rpc_argp;
  2788. struct nfs_renameres *res = msg->rpc_resp;
  2789. msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME];
  2790. res->server = server;
  2791. nfs41_init_sequence(&arg->seq_args, &res->seq_res, 1);
  2792. }
  2793. static void nfs4_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
  2794. {
  2795. nfs4_setup_sequence(NFS_SERVER(data->old_dir),
  2796. &data->args.seq_args,
  2797. &data->res.seq_res,
  2798. task);
  2799. }
  2800. static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
  2801. struct inode *new_dir)
  2802. {
  2803. struct nfs_renameres *res = task->tk_msg.rpc_resp;
  2804. if (!nfs4_sequence_done(task, &res->seq_res))
  2805. return 0;
  2806. if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN)
  2807. return 0;
  2808. update_changeattr(old_dir, &res->old_cinfo);
  2809. update_changeattr(new_dir, &res->new_cinfo);
  2810. return 1;
  2811. }
  2812. static int _nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
  2813. struct inode *new_dir, struct qstr *new_name)
  2814. {
  2815. struct nfs_server *server = NFS_SERVER(old_dir);
  2816. struct nfs_renameargs arg = {
  2817. .old_dir = NFS_FH(old_dir),
  2818. .new_dir = NFS_FH(new_dir),
  2819. .old_name = old_name,
  2820. .new_name = new_name,
  2821. };
  2822. struct nfs_renameres res = {
  2823. .server = server,
  2824. };
  2825. struct rpc_message msg = {
  2826. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME],
  2827. .rpc_argp = &arg,
  2828. .rpc_resp = &res,
  2829. };
  2830. int status = -ENOMEM;
  2831. status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
  2832. if (!status) {
  2833. update_changeattr(old_dir, &res.old_cinfo);
  2834. update_changeattr(new_dir, &res.new_cinfo);
  2835. }
  2836. return status;
  2837. }
  2838. static int nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
  2839. struct inode *new_dir, struct qstr *new_name)
  2840. {
  2841. struct nfs4_exception exception = { };
  2842. int err;
  2843. do {
  2844. err = nfs4_handle_exception(NFS_SERVER(old_dir),
  2845. _nfs4_proc_rename(old_dir, old_name,
  2846. new_dir, new_name),
  2847. &exception);
  2848. } while (exception.retry);
  2849. return err;
  2850. }
  2851. static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
  2852. {
  2853. struct nfs_server *server = NFS_SERVER(inode);
  2854. struct nfs4_link_arg arg = {
  2855. .fh = NFS_FH(inode),
  2856. .dir_fh = NFS_FH(dir),
  2857. .name = name,
  2858. .bitmask = server->attr_bitmask,
  2859. };
  2860. struct nfs4_link_res res = {
  2861. .server = server,
  2862. };
  2863. struct rpc_message msg = {
  2864. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK],
  2865. .rpc_argp = &arg,
  2866. .rpc_resp = &res,
  2867. };
  2868. int status = -ENOMEM;
  2869. res.fattr = nfs_alloc_fattr();
  2870. if (res.fattr == NULL)
  2871. goto out;
  2872. status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
  2873. if (!status) {
  2874. update_changeattr(dir, &res.cinfo);
  2875. nfs_post_op_update_inode(inode, res.fattr);
  2876. }
  2877. out:
  2878. nfs_free_fattr(res.fattr);
  2879. return status;
  2880. }
  2881. static int nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
  2882. {
  2883. struct nfs4_exception exception = { };
  2884. int err;
  2885. do {
  2886. err = nfs4_handle_exception(NFS_SERVER(inode),
  2887. _nfs4_proc_link(inode, dir, name),
  2888. &exception);
  2889. } while (exception.retry);
  2890. return err;
  2891. }
  2892. struct nfs4_createdata {
  2893. struct rpc_message msg;
  2894. struct nfs4_create_arg arg;
  2895. struct nfs4_create_res res;
  2896. struct nfs_fh fh;
  2897. struct nfs_fattr fattr;
  2898. };
  2899. static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
  2900. struct qstr *name, struct iattr *sattr, u32 ftype)
  2901. {
  2902. struct nfs4_createdata *data;
  2903. data = kzalloc(sizeof(*data), GFP_KERNEL);
  2904. if (data != NULL) {
  2905. struct nfs_server *server = NFS_SERVER(dir);
  2906. data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE];
  2907. data->msg.rpc_argp = &data->arg;
  2908. data->msg.rpc_resp = &data->res;
  2909. data->arg.dir_fh = NFS_FH(dir);
  2910. data->arg.server = server;
  2911. data->arg.name = name;
  2912. data->arg.attrs = sattr;
  2913. data->arg.ftype = ftype;
  2914. data->arg.bitmask = server->attr_bitmask;
  2915. data->res.server = server;
  2916. data->res.fh = &data->fh;
  2917. data->res.fattr = &data->fattr;
  2918. nfs_fattr_init(data->res.fattr);
  2919. }
  2920. return data;
  2921. }
  2922. static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data)
  2923. {
  2924. int status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &data->msg,
  2925. &data->arg.seq_args, &data->res.seq_res, 1);
  2926. if (status == 0) {
  2927. update_changeattr(dir, &data->res.dir_cinfo);
  2928. status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
  2929. }
  2930. return status;
  2931. }
  2932. static void nfs4_free_createdata(struct nfs4_createdata *data)
  2933. {
  2934. kfree(data);
  2935. }
  2936. static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
  2937. struct page *page, unsigned int len, struct iattr *sattr)
  2938. {
  2939. struct nfs4_createdata *data;
  2940. int status = -ENAMETOOLONG;
  2941. if (len > NFS4_MAXPATHLEN)
  2942. goto out;
  2943. status = -ENOMEM;
  2944. data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK);
  2945. if (data == NULL)
  2946. goto out;
  2947. data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK];
  2948. data->arg.u.symlink.pages = &page;
  2949. data->arg.u.symlink.len = len;
  2950. status = nfs4_do_create(dir, dentry, data);
  2951. nfs4_free_createdata(data);
  2952. out:
  2953. return status;
  2954. }
  2955. static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
  2956. struct page *page, unsigned int len, struct iattr *sattr)
  2957. {
  2958. struct nfs4_exception exception = { };
  2959. int err;
  2960. do {
  2961. err = nfs4_handle_exception(NFS_SERVER(dir),
  2962. _nfs4_proc_symlink(dir, dentry, page,
  2963. len, sattr),
  2964. &exception);
  2965. } while (exception.retry);
  2966. return err;
  2967. }
  2968. static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
  2969. struct iattr *sattr)
  2970. {
  2971. struct nfs4_createdata *data;
  2972. int status = -ENOMEM;
  2973. data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR);
  2974. if (data == NULL)
  2975. goto out;
  2976. status = nfs4_do_create(dir, dentry, data);
  2977. nfs4_free_createdata(data);
  2978. out:
  2979. return status;
  2980. }
  2981. static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
  2982. struct iattr *sattr)
  2983. {
  2984. struct nfs4_exception exception = { };
  2985. int err;
  2986. sattr->ia_mode &= ~current_umask();
  2987. do {
  2988. err = nfs4_handle_exception(NFS_SERVER(dir),
  2989. _nfs4_proc_mkdir(dir, dentry, sattr),
  2990. &exception);
  2991. } while (exception.retry);
  2992. return err;
  2993. }
  2994. static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
  2995. u64 cookie, struct page **pages, unsigned int count, int plus)
  2996. {
  2997. struct inode *dir = dentry->d_inode;
  2998. struct nfs4_readdir_arg args = {
  2999. .fh = NFS_FH(dir),
  3000. .pages = pages,
  3001. .pgbase = 0,
  3002. .count = count,
  3003. .bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask,
  3004. .plus = plus,
  3005. };
  3006. struct nfs4_readdir_res res;
  3007. struct rpc_message msg = {
  3008. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR],
  3009. .rpc_argp = &args,
  3010. .rpc_resp = &res,
  3011. .rpc_cred = cred,
  3012. };
  3013. int status;
  3014. dprintk("%s: dentry = %s/%s, cookie = %Lu\n", __func__,
  3015. dentry->d_parent->d_name.name,
  3016. dentry->d_name.name,
  3017. (unsigned long long)cookie);
  3018. nfs4_setup_readdir(cookie, NFS_I(dir)->cookieverf, dentry, &args);
  3019. res.pgbase = args.pgbase;
  3020. status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &msg, &args.seq_args, &res.seq_res, 0);
  3021. if (status >= 0) {
  3022. memcpy(NFS_I(dir)->cookieverf, res.verifier.data, NFS4_VERIFIER_SIZE);
  3023. status += args.pgbase;
  3024. }
  3025. nfs_invalidate_atime(dir);
  3026. dprintk("%s: returns %d\n", __func__, status);
  3027. return status;
  3028. }
  3029. static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
  3030. u64 cookie, struct page **pages, unsigned int count, int plus)
  3031. {
  3032. struct nfs4_exception exception = { };
  3033. int err;
  3034. do {
  3035. err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode),
  3036. _nfs4_proc_readdir(dentry, cred, cookie,
  3037. pages, count, plus),
  3038. &exception);
  3039. } while (exception.retry);
  3040. return err;
  3041. }
  3042. static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
  3043. struct iattr *sattr, dev_t rdev)
  3044. {
  3045. struct nfs4_createdata *data;
  3046. int mode = sattr->ia_mode;
  3047. int status = -ENOMEM;
  3048. data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK);
  3049. if (data == NULL)
  3050. goto out;
  3051. if (S_ISFIFO(mode))
  3052. data->arg.ftype = NF4FIFO;
  3053. else if (S_ISBLK(mode)) {
  3054. data->arg.ftype = NF4BLK;
  3055. data->arg.u.device.specdata1 = MAJOR(rdev);
  3056. data->arg.u.device.specdata2 = MINOR(rdev);
  3057. }
  3058. else if (S_ISCHR(mode)) {
  3059. data->arg.ftype = NF4CHR;
  3060. data->arg.u.device.specdata1 = MAJOR(rdev);
  3061. data->arg.u.device.specdata2 = MINOR(rdev);
  3062. } else if (!S_ISSOCK(mode)) {
  3063. status = -EINVAL;
  3064. goto out_free;
  3065. }
  3066. status = nfs4_do_create(dir, dentry, data);
  3067. out_free:
  3068. nfs4_free_createdata(data);
  3069. out:
  3070. return status;
  3071. }
  3072. static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
  3073. struct iattr *sattr, dev_t rdev)
  3074. {
  3075. struct nfs4_exception exception = { };
  3076. int err;
  3077. sattr->ia_mode &= ~current_umask();
  3078. do {
  3079. err = nfs4_handle_exception(NFS_SERVER(dir),
  3080. _nfs4_proc_mknod(dir, dentry, sattr, rdev),
  3081. &exception);
  3082. } while (exception.retry);
  3083. return err;
  3084. }
  3085. static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
  3086. struct nfs_fsstat *fsstat)
  3087. {
  3088. struct nfs4_statfs_arg args = {
  3089. .fh = fhandle,
  3090. .bitmask = server->attr_bitmask,
  3091. };
  3092. struct nfs4_statfs_res res = {
  3093. .fsstat = fsstat,
  3094. };
  3095. struct rpc_message msg = {
  3096. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS],
  3097. .rpc_argp = &args,
  3098. .rpc_resp = &res,
  3099. };
  3100. nfs_fattr_init(fsstat->fattr);
  3101. return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
  3102. }
  3103. static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat)
  3104. {
  3105. struct nfs4_exception exception = { };
  3106. int err;
  3107. do {
  3108. err = nfs4_handle_exception(server,
  3109. _nfs4_proc_statfs(server, fhandle, fsstat),
  3110. &exception);
  3111. } while (exception.retry);
  3112. return err;
  3113. }
  3114. static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
  3115. struct nfs_fsinfo *fsinfo)
  3116. {
  3117. struct nfs4_fsinfo_arg args = {
  3118. .fh = fhandle,
  3119. .bitmask = server->attr_bitmask,
  3120. };
  3121. struct nfs4_fsinfo_res res = {
  3122. .fsinfo = fsinfo,
  3123. };
  3124. struct rpc_message msg = {
  3125. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO],
  3126. .rpc_argp = &args,
  3127. .rpc_resp = &res,
  3128. };
  3129. return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
  3130. }
  3131. static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
  3132. {
  3133. struct nfs4_exception exception = { };
  3134. int err;
  3135. do {
  3136. err = nfs4_handle_exception(server,
  3137. _nfs4_do_fsinfo(server, fhandle, fsinfo),
  3138. &exception);
  3139. } while (exception.retry);
  3140. return err;
  3141. }
  3142. static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
  3143. {
  3144. int error;
  3145. nfs_fattr_init(fsinfo->fattr);
  3146. error = nfs4_do_fsinfo(server, fhandle, fsinfo);
  3147. if (error == 0) {
  3148. /* block layout checks this! */
  3149. server->pnfs_blksize = fsinfo->blksize;
  3150. set_pnfs_layoutdriver(server, fhandle, fsinfo->layouttype);
  3151. }
  3152. return error;
  3153. }
  3154. static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
  3155. struct nfs_pathconf *pathconf)
  3156. {
  3157. struct nfs4_pathconf_arg args = {
  3158. .fh = fhandle,
  3159. .bitmask = server->attr_bitmask,
  3160. };
  3161. struct nfs4_pathconf_res res = {
  3162. .pathconf = pathconf,
  3163. };
  3164. struct rpc_message msg = {
  3165. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF],
  3166. .rpc_argp = &args,
  3167. .rpc_resp = &res,
  3168. };
  3169. /* None of the pathconf attributes are mandatory to implement */
  3170. if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) {
  3171. memset(pathconf, 0, sizeof(*pathconf));
  3172. return 0;
  3173. }
  3174. nfs_fattr_init(pathconf->fattr);
  3175. return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
  3176. }
  3177. static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
  3178. struct nfs_pathconf *pathconf)
  3179. {
  3180. struct nfs4_exception exception = { };
  3181. int err;
  3182. do {
  3183. err = nfs4_handle_exception(server,
  3184. _nfs4_proc_pathconf(server, fhandle, pathconf),
  3185. &exception);
  3186. } while (exception.retry);
  3187. return err;
  3188. }
  3189. int nfs4_set_rw_stateid(nfs4_stateid *stateid,
  3190. const struct nfs_open_context *ctx,
  3191. const struct nfs_lock_context *l_ctx,
  3192. fmode_t fmode)
  3193. {
  3194. const struct nfs_lockowner *lockowner = NULL;
  3195. if (l_ctx != NULL)
  3196. lockowner = &l_ctx->lockowner;
  3197. return nfs4_select_rw_stateid(stateid, ctx->state, fmode, lockowner);
  3198. }
  3199. EXPORT_SYMBOL_GPL(nfs4_set_rw_stateid);
  3200. static bool nfs4_stateid_is_current(nfs4_stateid *stateid,
  3201. const struct nfs_open_context *ctx,
  3202. const struct nfs_lock_context *l_ctx,
  3203. fmode_t fmode)
  3204. {
  3205. nfs4_stateid current_stateid;
  3206. if (nfs4_set_rw_stateid(&current_stateid, ctx, l_ctx, fmode))
  3207. return false;
  3208. return nfs4_stateid_match(stateid, &current_stateid);
  3209. }
  3210. static bool nfs4_error_stateid_expired(int err)
  3211. {
  3212. switch (err) {
  3213. case -NFS4ERR_DELEG_REVOKED:
  3214. case -NFS4ERR_ADMIN_REVOKED:
  3215. case -NFS4ERR_BAD_STATEID:
  3216. case -NFS4ERR_STALE_STATEID:
  3217. case -NFS4ERR_OLD_STATEID:
  3218. case -NFS4ERR_OPENMODE:
  3219. case -NFS4ERR_EXPIRED:
  3220. return true;
  3221. }
  3222. return false;
  3223. }
  3224. void __nfs4_read_done_cb(struct nfs_read_data *data)
  3225. {
  3226. nfs_invalidate_atime(data->header->inode);
  3227. }
  3228. static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_read_data *data)
  3229. {
  3230. struct nfs_server *server = NFS_SERVER(data->header->inode);
  3231. if (nfs4_async_handle_error(task, server, data->args.context->state) == -EAGAIN) {
  3232. rpc_restart_call_prepare(task);
  3233. return -EAGAIN;
  3234. }
  3235. __nfs4_read_done_cb(data);
  3236. if (task->tk_status > 0)
  3237. renew_lease(server, data->timestamp);
  3238. return 0;
  3239. }
  3240. static bool nfs4_read_stateid_changed(struct rpc_task *task,
  3241. struct nfs_readargs *args)
  3242. {
  3243. if (!nfs4_error_stateid_expired(task->tk_status) ||
  3244. nfs4_stateid_is_current(&args->stateid,
  3245. args->context,
  3246. args->lock_context,
  3247. FMODE_READ))
  3248. return false;
  3249. rpc_restart_call_prepare(task);
  3250. return true;
  3251. }
  3252. static int nfs4_read_done(struct rpc_task *task, struct nfs_read_data *data)
  3253. {
  3254. dprintk("--> %s\n", __func__);
  3255. if (!nfs4_sequence_done(task, &data->res.seq_res))
  3256. return -EAGAIN;
  3257. if (nfs4_read_stateid_changed(task, &data->args))
  3258. return -EAGAIN;
  3259. return data->read_done_cb ? data->read_done_cb(task, data) :
  3260. nfs4_read_done_cb(task, data);
  3261. }
  3262. static void nfs4_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
  3263. {
  3264. data->timestamp = jiffies;
  3265. data->read_done_cb = nfs4_read_done_cb;
  3266. msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ];
  3267. nfs41_init_sequence(&data->args.seq_args, &data->res.seq_res, 0);
  3268. }
  3269. static void nfs4_proc_read_rpc_prepare(struct rpc_task *task, struct nfs_read_data *data)
  3270. {
  3271. if (nfs4_setup_sequence(NFS_SERVER(data->header->inode),
  3272. &data->args.seq_args,
  3273. &data->res.seq_res,
  3274. task))
  3275. return;
  3276. nfs4_set_rw_stateid(&data->args.stateid, data->args.context,
  3277. data->args.lock_context, FMODE_READ);
  3278. }
  3279. static int nfs4_write_done_cb(struct rpc_task *task, struct nfs_write_data *data)
  3280. {
  3281. struct inode *inode = data->header->inode;
  3282. if (nfs4_async_handle_error(task, NFS_SERVER(inode), data->args.context->state) == -EAGAIN) {
  3283. rpc_restart_call_prepare(task);
  3284. return -EAGAIN;
  3285. }
  3286. if (task->tk_status >= 0) {
  3287. renew_lease(NFS_SERVER(inode), data->timestamp);
  3288. nfs_post_op_update_inode_force_wcc(inode, &data->fattr);
  3289. }
  3290. return 0;
  3291. }
  3292. static bool nfs4_write_stateid_changed(struct rpc_task *task,
  3293. struct nfs_writeargs *args)
  3294. {
  3295. if (!nfs4_error_stateid_expired(task->tk_status) ||
  3296. nfs4_stateid_is_current(&args->stateid,
  3297. args->context,
  3298. args->lock_context,
  3299. FMODE_WRITE))
  3300. return false;
  3301. rpc_restart_call_prepare(task);
  3302. return true;
  3303. }
  3304. static int nfs4_write_done(struct rpc_task *task, struct nfs_write_data *data)
  3305. {
  3306. if (!nfs4_sequence_done(task, &data->res.seq_res))
  3307. return -EAGAIN;
  3308. if (nfs4_write_stateid_changed(task, &data->args))
  3309. return -EAGAIN;
  3310. return data->write_done_cb ? data->write_done_cb(task, data) :
  3311. nfs4_write_done_cb(task, data);
  3312. }
  3313. static
  3314. bool nfs4_write_need_cache_consistency_data(const struct nfs_write_data *data)
  3315. {
  3316. const struct nfs_pgio_header *hdr = data->header;
  3317. /* Don't request attributes for pNFS or O_DIRECT writes */
  3318. if (data->ds_clp != NULL || hdr->dreq != NULL)
  3319. return false;
  3320. /* Otherwise, request attributes if and only if we don't hold
  3321. * a delegation
  3322. */
  3323. return nfs4_have_delegation(hdr->inode, FMODE_READ) == 0;
  3324. }
  3325. static void nfs4_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
  3326. {
  3327. struct nfs_server *server = NFS_SERVER(data->header->inode);
  3328. if (!nfs4_write_need_cache_consistency_data(data)) {
  3329. data->args.bitmask = NULL;
  3330. data->res.fattr = NULL;
  3331. } else
  3332. data->args.bitmask = server->cache_consistency_bitmask;
  3333. if (!data->write_done_cb)
  3334. data->write_done_cb = nfs4_write_done_cb;
  3335. data->res.server = server;
  3336. data->timestamp = jiffies;
  3337. msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE];
  3338. nfs41_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
  3339. }
  3340. static void nfs4_proc_write_rpc_prepare(struct rpc_task *task, struct nfs_write_data *data)
  3341. {
  3342. if (nfs4_setup_sequence(NFS_SERVER(data->header->inode),
  3343. &data->args.seq_args,
  3344. &data->res.seq_res,
  3345. task))
  3346. return;
  3347. nfs4_set_rw_stateid(&data->args.stateid, data->args.context,
  3348. data->args.lock_context, FMODE_WRITE);
  3349. }
  3350. static void nfs4_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
  3351. {
  3352. nfs4_setup_sequence(NFS_SERVER(data->inode),
  3353. &data->args.seq_args,
  3354. &data->res.seq_res,
  3355. task);
  3356. }
  3357. static int nfs4_commit_done_cb(struct rpc_task *task, struct nfs_commit_data *data)
  3358. {
  3359. struct inode *inode = data->inode;
  3360. if (nfs4_async_handle_error(task, NFS_SERVER(inode), NULL) == -EAGAIN) {
  3361. rpc_restart_call_prepare(task);
  3362. return -EAGAIN;
  3363. }
  3364. return 0;
  3365. }
  3366. static int nfs4_commit_done(struct rpc_task *task, struct nfs_commit_data *data)
  3367. {
  3368. if (!nfs4_sequence_done(task, &data->res.seq_res))
  3369. return -EAGAIN;
  3370. return data->commit_done_cb(task, data);
  3371. }
  3372. static void nfs4_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
  3373. {
  3374. struct nfs_server *server = NFS_SERVER(data->inode);
  3375. if (data->commit_done_cb == NULL)
  3376. data->commit_done_cb = nfs4_commit_done_cb;
  3377. data->res.server = server;
  3378. msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT];
  3379. nfs41_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
  3380. }
  3381. struct nfs4_renewdata {
  3382. struct nfs_client *client;
  3383. unsigned long timestamp;
  3384. };
  3385. /*
  3386. * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special
  3387. * standalone procedure for queueing an asynchronous RENEW.
  3388. */
  3389. static void nfs4_renew_release(void *calldata)
  3390. {
  3391. struct nfs4_renewdata *data = calldata;
  3392. struct nfs_client *clp = data->client;
  3393. if (atomic_read(&clp->cl_count) > 1)
  3394. nfs4_schedule_state_renewal(clp);
  3395. nfs_put_client(clp);
  3396. kfree(data);
  3397. }
  3398. static void nfs4_renew_done(struct rpc_task *task, void *calldata)
  3399. {
  3400. struct nfs4_renewdata *data = calldata;
  3401. struct nfs_client *clp = data->client;
  3402. unsigned long timestamp = data->timestamp;
  3403. if (task->tk_status < 0) {
  3404. /* Unless we're shutting down, schedule state recovery! */
  3405. if (test_bit(NFS_CS_RENEWD, &clp->cl_res_state) == 0)
  3406. return;
  3407. if (task->tk_status != NFS4ERR_CB_PATH_DOWN) {
  3408. nfs4_schedule_lease_recovery(clp);
  3409. return;
  3410. }
  3411. nfs4_schedule_path_down_recovery(clp);
  3412. }
  3413. do_renew_lease(clp, timestamp);
  3414. }
  3415. static const struct rpc_call_ops nfs4_renew_ops = {
  3416. .rpc_call_done = nfs4_renew_done,
  3417. .rpc_release = nfs4_renew_release,
  3418. };
  3419. static int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
  3420. {
  3421. struct rpc_message msg = {
  3422. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
  3423. .rpc_argp = clp,
  3424. .rpc_cred = cred,
  3425. };
  3426. struct nfs4_renewdata *data;
  3427. if (renew_flags == 0)
  3428. return 0;
  3429. if (!atomic_inc_not_zero(&clp->cl_count))
  3430. return -EIO;
  3431. data = kmalloc(sizeof(*data), GFP_NOFS);
  3432. if (data == NULL)
  3433. return -ENOMEM;
  3434. data->client = clp;
  3435. data->timestamp = jiffies;
  3436. return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT,
  3437. &nfs4_renew_ops, data);
  3438. }
  3439. static int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred)
  3440. {
  3441. struct rpc_message msg = {
  3442. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENEW],
  3443. .rpc_argp = clp,
  3444. .rpc_cred = cred,
  3445. };
  3446. unsigned long now = jiffies;
  3447. int status;
  3448. status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
  3449. if (status < 0)
  3450. return status;
  3451. do_renew_lease(clp, now);
  3452. return 0;
  3453. }
  3454. static inline int nfs4_server_supports_acls(struct nfs_server *server)
  3455. {
  3456. return (server->caps & NFS_CAP_ACLS)
  3457. && (server->acl_bitmask & ACL4_SUPPORT_ALLOW_ACL)
  3458. && (server->acl_bitmask & ACL4_SUPPORT_DENY_ACL);
  3459. }
  3460. /* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_SIZE, and that
  3461. * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_SIZE) bytes on
  3462. * the stack.
  3463. */
  3464. #define NFS4ACL_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE)
  3465. static int buf_to_pages_noslab(const void *buf, size_t buflen,
  3466. struct page **pages, unsigned int *pgbase)
  3467. {
  3468. struct page *newpage, **spages;
  3469. int rc = 0;
  3470. size_t len;
  3471. spages = pages;
  3472. do {
  3473. len = min_t(size_t, PAGE_SIZE, buflen);
  3474. newpage = alloc_page(GFP_KERNEL);
  3475. if (newpage == NULL)
  3476. goto unwind;
  3477. memcpy(page_address(newpage), buf, len);
  3478. buf += len;
  3479. buflen -= len;
  3480. *pages++ = newpage;
  3481. rc++;
  3482. } while (buflen != 0);
  3483. return rc;
  3484. unwind:
  3485. for(; rc > 0; rc--)
  3486. __free_page(spages[rc-1]);
  3487. return -ENOMEM;
  3488. }
  3489. struct nfs4_cached_acl {
  3490. int cached;
  3491. size_t len;
  3492. char data[0];
  3493. };
  3494. static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl)
  3495. {
  3496. struct nfs_inode *nfsi = NFS_I(inode);
  3497. spin_lock(&inode->i_lock);
  3498. kfree(nfsi->nfs4_acl);
  3499. nfsi->nfs4_acl = acl;
  3500. spin_unlock(&inode->i_lock);
  3501. }
  3502. static void nfs4_zap_acl_attr(struct inode *inode)
  3503. {
  3504. nfs4_set_cached_acl(inode, NULL);
  3505. }
  3506. static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen)
  3507. {
  3508. struct nfs_inode *nfsi = NFS_I(inode);
  3509. struct nfs4_cached_acl *acl;
  3510. int ret = -ENOENT;
  3511. spin_lock(&inode->i_lock);
  3512. acl = nfsi->nfs4_acl;
  3513. if (acl == NULL)
  3514. goto out;
  3515. if (buf == NULL) /* user is just asking for length */
  3516. goto out_len;
  3517. if (acl->cached == 0)
  3518. goto out;
  3519. ret = -ERANGE; /* see getxattr(2) man page */
  3520. if (acl->len > buflen)
  3521. goto out;
  3522. memcpy(buf, acl->data, acl->len);
  3523. out_len:
  3524. ret = acl->len;
  3525. out:
  3526. spin_unlock(&inode->i_lock);
  3527. return ret;
  3528. }
  3529. static void nfs4_write_cached_acl(struct inode *inode, struct page **pages, size_t pgbase, size_t acl_len)
  3530. {
  3531. struct nfs4_cached_acl *acl;
  3532. size_t buflen = sizeof(*acl) + acl_len;
  3533. if (buflen <= PAGE_SIZE) {
  3534. acl = kmalloc(buflen, GFP_KERNEL);
  3535. if (acl == NULL)
  3536. goto out;
  3537. acl->cached = 1;
  3538. _copy_from_pages(acl->data, pages, pgbase, acl_len);
  3539. } else {
  3540. acl = kmalloc(sizeof(*acl), GFP_KERNEL);
  3541. if (acl == NULL)
  3542. goto out;
  3543. acl->cached = 0;
  3544. }
  3545. acl->len = acl_len;
  3546. out:
  3547. nfs4_set_cached_acl(inode, acl);
  3548. }
  3549. /*
  3550. * The getxattr API returns the required buffer length when called with a
  3551. * NULL buf. The NFSv4 acl tool then calls getxattr again after allocating
  3552. * the required buf. On a NULL buf, we send a page of data to the server
  3553. * guessing that the ACL request can be serviced by a page. If so, we cache
  3554. * up to the page of ACL data, and the 2nd call to getxattr is serviced by
  3555. * the cache. If not so, we throw away the page, and cache the required
  3556. * length. The next getxattr call will then produce another round trip to
  3557. * the server, this time with the input buf of the required size.
  3558. */
  3559. static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
  3560. {
  3561. struct page *pages[NFS4ACL_MAXPAGES] = {NULL, };
  3562. struct nfs_getaclargs args = {
  3563. .fh = NFS_FH(inode),
  3564. .acl_pages = pages,
  3565. .acl_len = buflen,
  3566. };
  3567. struct nfs_getaclres res = {
  3568. .acl_len = buflen,
  3569. };
  3570. struct rpc_message msg = {
  3571. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL],
  3572. .rpc_argp = &args,
  3573. .rpc_resp = &res,
  3574. };
  3575. unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);
  3576. int ret = -ENOMEM, i;
  3577. /* As long as we're doing a round trip to the server anyway,
  3578. * let's be prepared for a page of acl data. */
  3579. if (npages == 0)
  3580. npages = 1;
  3581. if (npages > ARRAY_SIZE(pages))
  3582. return -ERANGE;
  3583. for (i = 0; i < npages; i++) {
  3584. pages[i] = alloc_page(GFP_KERNEL);
  3585. if (!pages[i])
  3586. goto out_free;
  3587. }
  3588. /* for decoding across pages */
  3589. res.acl_scratch = alloc_page(GFP_KERNEL);
  3590. if (!res.acl_scratch)
  3591. goto out_free;
  3592. args.acl_len = npages * PAGE_SIZE;
  3593. args.acl_pgbase = 0;
  3594. dprintk("%s buf %p buflen %zu npages %d args.acl_len %zu\n",
  3595. __func__, buf, buflen, npages, args.acl_len);
  3596. ret = nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode),
  3597. &msg, &args.seq_args, &res.seq_res, 0);
  3598. if (ret)
  3599. goto out_free;
  3600. /* Handle the case where the passed-in buffer is too short */
  3601. if (res.acl_flags & NFS4_ACL_TRUNC) {
  3602. /* Did the user only issue a request for the acl length? */
  3603. if (buf == NULL)
  3604. goto out_ok;
  3605. ret = -ERANGE;
  3606. goto out_free;
  3607. }
  3608. nfs4_write_cached_acl(inode, pages, res.acl_data_offset, res.acl_len);
  3609. if (buf) {
  3610. if (res.acl_len > buflen) {
  3611. ret = -ERANGE;
  3612. goto out_free;
  3613. }
  3614. _copy_from_pages(buf, pages, res.acl_data_offset, res.acl_len);
  3615. }
  3616. out_ok:
  3617. ret = res.acl_len;
  3618. out_free:
  3619. for (i = 0; i < npages; i++)
  3620. if (pages[i])
  3621. __free_page(pages[i]);
  3622. if (res.acl_scratch)
  3623. __free_page(res.acl_scratch);
  3624. return ret;
  3625. }
  3626. static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
  3627. {
  3628. struct nfs4_exception exception = { };
  3629. ssize_t ret;
  3630. do {
  3631. ret = __nfs4_get_acl_uncached(inode, buf, buflen);
  3632. if (ret >= 0)
  3633. break;
  3634. ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception);
  3635. } while (exception.retry);
  3636. return ret;
  3637. }
  3638. static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen)
  3639. {
  3640. struct nfs_server *server = NFS_SERVER(inode);
  3641. int ret;
  3642. if (!nfs4_server_supports_acls(server))
  3643. return -EOPNOTSUPP;
  3644. ret = nfs_revalidate_inode(server, inode);
  3645. if (ret < 0)
  3646. return ret;
  3647. if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL)
  3648. nfs_zap_acl_cache(inode);
  3649. ret = nfs4_read_cached_acl(inode, buf, buflen);
  3650. if (ret != -ENOENT)
  3651. /* -ENOENT is returned if there is no ACL or if there is an ACL
  3652. * but no cached acl data, just the acl length */
  3653. return ret;
  3654. return nfs4_get_acl_uncached(inode, buf, buflen);
  3655. }
  3656. static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
  3657. {
  3658. struct nfs_server *server = NFS_SERVER(inode);
  3659. struct page *pages[NFS4ACL_MAXPAGES];
  3660. struct nfs_setaclargs arg = {
  3661. .fh = NFS_FH(inode),
  3662. .acl_pages = pages,
  3663. .acl_len = buflen,
  3664. };
  3665. struct nfs_setaclres res;
  3666. struct rpc_message msg = {
  3667. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETACL],
  3668. .rpc_argp = &arg,
  3669. .rpc_resp = &res,
  3670. };
  3671. unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);
  3672. int ret, i;
  3673. if (!nfs4_server_supports_acls(server))
  3674. return -EOPNOTSUPP;
  3675. if (npages > ARRAY_SIZE(pages))
  3676. return -ERANGE;
  3677. i = buf_to_pages_noslab(buf, buflen, arg.acl_pages, &arg.acl_pgbase);
  3678. if (i < 0)
  3679. return i;
  3680. nfs4_inode_return_delegation(inode);
  3681. ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
  3682. /*
  3683. * Free each page after tx, so the only ref left is
  3684. * held by the network stack
  3685. */
  3686. for (; i > 0; i--)
  3687. put_page(pages[i-1]);
  3688. /*
  3689. * Acl update can result in inode attribute update.
  3690. * so mark the attribute cache invalid.
  3691. */
  3692. spin_lock(&inode->i_lock);
  3693. NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;
  3694. spin_unlock(&inode->i_lock);
  3695. nfs_access_zap_cache(inode);
  3696. nfs_zap_acl_cache(inode);
  3697. return ret;
  3698. }
  3699. static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
  3700. {
  3701. struct nfs4_exception exception = { };
  3702. int err;
  3703. do {
  3704. err = nfs4_handle_exception(NFS_SERVER(inode),
  3705. __nfs4_proc_set_acl(inode, buf, buflen),
  3706. &exception);
  3707. } while (exception.retry);
  3708. return err;
  3709. }
  3710. static int
  3711. nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server, struct nfs4_state *state)
  3712. {
  3713. struct nfs_client *clp = server->nfs_client;
  3714. if (task->tk_status >= 0)
  3715. return 0;
  3716. switch(task->tk_status) {
  3717. case -NFS4ERR_DELEG_REVOKED:
  3718. case -NFS4ERR_ADMIN_REVOKED:
  3719. case -NFS4ERR_BAD_STATEID:
  3720. if (state == NULL)
  3721. break;
  3722. nfs_remove_bad_delegation(state->inode);
  3723. case -NFS4ERR_OPENMODE:
  3724. if (state == NULL)
  3725. break;
  3726. if (nfs4_schedule_stateid_recovery(server, state) < 0)
  3727. goto stateid_invalid;
  3728. goto wait_on_recovery;
  3729. case -NFS4ERR_EXPIRED:
  3730. if (state != NULL) {
  3731. if (nfs4_schedule_stateid_recovery(server, state) < 0)
  3732. goto stateid_invalid;
  3733. }
  3734. case -NFS4ERR_STALE_STATEID:
  3735. case -NFS4ERR_STALE_CLIENTID:
  3736. nfs4_schedule_lease_recovery(clp);
  3737. goto wait_on_recovery;
  3738. #if defined(CONFIG_NFS_V4_1)
  3739. case -NFS4ERR_BADSESSION:
  3740. case -NFS4ERR_BADSLOT:
  3741. case -NFS4ERR_BAD_HIGH_SLOT:
  3742. case -NFS4ERR_DEADSESSION:
  3743. case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
  3744. case -NFS4ERR_SEQ_FALSE_RETRY:
  3745. case -NFS4ERR_SEQ_MISORDERED:
  3746. dprintk("%s ERROR %d, Reset session\n", __func__,
  3747. task->tk_status);
  3748. nfs4_schedule_session_recovery(clp->cl_session, task->tk_status);
  3749. task->tk_status = 0;
  3750. return -EAGAIN;
  3751. #endif /* CONFIG_NFS_V4_1 */
  3752. case -NFS4ERR_DELAY:
  3753. nfs_inc_server_stats(server, NFSIOS_DELAY);
  3754. case -NFS4ERR_GRACE:
  3755. rpc_delay(task, NFS4_POLL_RETRY_MAX);
  3756. task->tk_status = 0;
  3757. return -EAGAIN;
  3758. case -NFS4ERR_RETRY_UNCACHED_REP:
  3759. case -NFS4ERR_OLD_STATEID:
  3760. task->tk_status = 0;
  3761. return -EAGAIN;
  3762. }
  3763. task->tk_status = nfs4_map_errors(task->tk_status);
  3764. return 0;
  3765. stateid_invalid:
  3766. task->tk_status = -EIO;
  3767. return 0;
  3768. wait_on_recovery:
  3769. rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL);
  3770. if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0)
  3771. rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task);
  3772. task->tk_status = 0;
  3773. return -EAGAIN;
  3774. }
  3775. static void nfs4_init_boot_verifier(const struct nfs_client *clp,
  3776. nfs4_verifier *bootverf)
  3777. {
  3778. __be32 verf[2];
  3779. if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
  3780. /* An impossible timestamp guarantees this value
  3781. * will never match a generated boot time. */
  3782. verf[0] = 0;
  3783. verf[1] = (__be32)(NSEC_PER_SEC + 1);
  3784. } else {
  3785. struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
  3786. verf[0] = (__be32)nn->boot_time.tv_sec;
  3787. verf[1] = (__be32)nn->boot_time.tv_nsec;
  3788. }
  3789. memcpy(bootverf->data, verf, sizeof(bootverf->data));
  3790. }
  3791. static unsigned int
  3792. nfs4_init_nonuniform_client_string(const struct nfs_client *clp,
  3793. char *buf, size_t len)
  3794. {
  3795. unsigned int result;
  3796. rcu_read_lock();
  3797. result = scnprintf(buf, len, "Linux NFSv4.0 %s/%s %s",
  3798. clp->cl_ipaddr,
  3799. rpc_peeraddr2str(clp->cl_rpcclient,
  3800. RPC_DISPLAY_ADDR),
  3801. rpc_peeraddr2str(clp->cl_rpcclient,
  3802. RPC_DISPLAY_PROTO));
  3803. rcu_read_unlock();
  3804. return result;
  3805. }
  3806. static unsigned int
  3807. nfs4_init_uniform_client_string(const struct nfs_client *clp,
  3808. char *buf, size_t len)
  3809. {
  3810. char *nodename = clp->cl_rpcclient->cl_nodename;
  3811. if (nfs4_client_id_uniquifier[0] != '\0')
  3812. nodename = nfs4_client_id_uniquifier;
  3813. return scnprintf(buf, len, "Linux NFSv%u.%u %s",
  3814. clp->rpc_ops->version, clp->cl_minorversion,
  3815. nodename);
  3816. }
  3817. /**
  3818. * nfs4_proc_setclientid - Negotiate client ID
  3819. * @clp: state data structure
  3820. * @program: RPC program for NFSv4 callback service
  3821. * @port: IP port number for NFS4 callback service
  3822. * @cred: RPC credential to use for this call
  3823. * @res: where to place the result
  3824. *
  3825. * Returns zero, a negative errno, or a negative NFS4ERR status code.
  3826. */
  3827. int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
  3828. unsigned short port, struct rpc_cred *cred,
  3829. struct nfs4_setclientid_res *res)
  3830. {
  3831. nfs4_verifier sc_verifier;
  3832. struct nfs4_setclientid setclientid = {
  3833. .sc_verifier = &sc_verifier,
  3834. .sc_prog = program,
  3835. .sc_cb_ident = clp->cl_cb_ident,
  3836. };
  3837. struct rpc_message msg = {
  3838. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID],
  3839. .rpc_argp = &setclientid,
  3840. .rpc_resp = res,
  3841. .rpc_cred = cred,
  3842. };
  3843. int status;
  3844. /* nfs_client_id4 */
  3845. nfs4_init_boot_verifier(clp, &sc_verifier);
  3846. if (test_bit(NFS_CS_MIGRATION, &clp->cl_flags))
  3847. setclientid.sc_name_len =
  3848. nfs4_init_uniform_client_string(clp,
  3849. setclientid.sc_name,
  3850. sizeof(setclientid.sc_name));
  3851. else
  3852. setclientid.sc_name_len =
  3853. nfs4_init_nonuniform_client_string(clp,
  3854. setclientid.sc_name,
  3855. sizeof(setclientid.sc_name));
  3856. /* cb_client4 */
  3857. rcu_read_lock();
  3858. setclientid.sc_netid_len = scnprintf(setclientid.sc_netid,
  3859. sizeof(setclientid.sc_netid),
  3860. rpc_peeraddr2str(clp->cl_rpcclient,
  3861. RPC_DISPLAY_NETID));
  3862. rcu_read_unlock();
  3863. setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr,
  3864. sizeof(setclientid.sc_uaddr), "%s.%u.%u",
  3865. clp->cl_ipaddr, port >> 8, port & 255);
  3866. dprintk("NFS call setclientid auth=%s, '%.*s'\n",
  3867. clp->cl_rpcclient->cl_auth->au_ops->au_name,
  3868. setclientid.sc_name_len, setclientid.sc_name);
  3869. status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
  3870. dprintk("NFS reply setclientid: %d\n", status);
  3871. return status;
  3872. }
  3873. /**
  3874. * nfs4_proc_setclientid_confirm - Confirm client ID
  3875. * @clp: state data structure
  3876. * @res: result of a previous SETCLIENTID
  3877. * @cred: RPC credential to use for this call
  3878. *
  3879. * Returns zero, a negative errno, or a negative NFS4ERR status code.
  3880. */
  3881. int nfs4_proc_setclientid_confirm(struct nfs_client *clp,
  3882. struct nfs4_setclientid_res *arg,
  3883. struct rpc_cred *cred)
  3884. {
  3885. struct nfs_fsinfo fsinfo;
  3886. struct rpc_message msg = {
  3887. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM],
  3888. .rpc_argp = arg,
  3889. .rpc_resp = &fsinfo,
  3890. .rpc_cred = cred,
  3891. };
  3892. unsigned long now;
  3893. int status;
  3894. dprintk("NFS call setclientid_confirm auth=%s, (client ID %llx)\n",
  3895. clp->cl_rpcclient->cl_auth->au_ops->au_name,
  3896. clp->cl_clientid);
  3897. now = jiffies;
  3898. status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
  3899. if (status == 0) {
  3900. spin_lock(&clp->cl_lock);
  3901. clp->cl_lease_time = fsinfo.lease_time * HZ;
  3902. clp->cl_last_renewal = now;
  3903. spin_unlock(&clp->cl_lock);
  3904. }
  3905. dprintk("NFS reply setclientid_confirm: %d\n", status);
  3906. return status;
  3907. }
  3908. struct nfs4_delegreturndata {
  3909. struct nfs4_delegreturnargs args;
  3910. struct nfs4_delegreturnres res;
  3911. struct nfs_fh fh;
  3912. nfs4_stateid stateid;
  3913. unsigned long timestamp;
  3914. struct nfs_fattr fattr;
  3915. int rpc_status;
  3916. };
  3917. static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)
  3918. {
  3919. struct nfs4_delegreturndata *data = calldata;
  3920. if (!nfs4_sequence_done(task, &data->res.seq_res))
  3921. return;
  3922. switch (task->tk_status) {
  3923. case -NFS4ERR_STALE_STATEID:
  3924. case -NFS4ERR_EXPIRED:
  3925. case 0:
  3926. renew_lease(data->res.server, data->timestamp);
  3927. break;
  3928. default:
  3929. if (nfs4_async_handle_error(task, data->res.server, NULL) ==
  3930. -EAGAIN) {
  3931. rpc_restart_call_prepare(task);
  3932. return;
  3933. }
  3934. }
  3935. data->rpc_status = task->tk_status;
  3936. }
  3937. static void nfs4_delegreturn_release(void *calldata)
  3938. {
  3939. kfree(calldata);
  3940. }
  3941. #if defined(CONFIG_NFS_V4_1)
  3942. static void nfs4_delegreturn_prepare(struct rpc_task *task, void *data)
  3943. {
  3944. struct nfs4_delegreturndata *d_data;
  3945. d_data = (struct nfs4_delegreturndata *)data;
  3946. nfs4_setup_sequence(d_data->res.server,
  3947. &d_data->args.seq_args,
  3948. &d_data->res.seq_res,
  3949. task);
  3950. }
  3951. #endif /* CONFIG_NFS_V4_1 */
  3952. static const struct rpc_call_ops nfs4_delegreturn_ops = {
  3953. #if defined(CONFIG_NFS_V4_1)
  3954. .rpc_call_prepare = nfs4_delegreturn_prepare,
  3955. #endif /* CONFIG_NFS_V4_1 */
  3956. .rpc_call_done = nfs4_delegreturn_done,
  3957. .rpc_release = nfs4_delegreturn_release,
  3958. };
  3959. static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
  3960. {
  3961. struct nfs4_delegreturndata *data;
  3962. struct nfs_server *server = NFS_SERVER(inode);
  3963. struct rpc_task *task;
  3964. struct rpc_message msg = {
  3965. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN],
  3966. .rpc_cred = cred,
  3967. };
  3968. struct rpc_task_setup task_setup_data = {
  3969. .rpc_client = server->client,
  3970. .rpc_message = &msg,
  3971. .callback_ops = &nfs4_delegreturn_ops,
  3972. .flags = RPC_TASK_ASYNC,
  3973. };
  3974. int status = 0;
  3975. data = kzalloc(sizeof(*data), GFP_NOFS);
  3976. if (data == NULL)
  3977. return -ENOMEM;
  3978. nfs41_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
  3979. data->args.fhandle = &data->fh;
  3980. data->args.stateid = &data->stateid;
  3981. data->args.bitmask = server->cache_consistency_bitmask;
  3982. nfs_copy_fh(&data->fh, NFS_FH(inode));
  3983. nfs4_stateid_copy(&data->stateid, stateid);
  3984. data->res.fattr = &data->fattr;
  3985. data->res.server = server;
  3986. nfs_fattr_init(data->res.fattr);
  3987. data->timestamp = jiffies;
  3988. data->rpc_status = 0;
  3989. task_setup_data.callback_data = data;
  3990. msg.rpc_argp = &data->args;
  3991. msg.rpc_resp = &data->res;
  3992. task = rpc_run_task(&task_setup_data);
  3993. if (IS_ERR(task))
  3994. return PTR_ERR(task);
  3995. if (!issync)
  3996. goto out;
  3997. status = nfs4_wait_for_completion_rpc_task(task);
  3998. if (status != 0)
  3999. goto out;
  4000. status = data->rpc_status;
  4001. if (status == 0)
  4002. nfs_post_op_update_inode_force_wcc(inode, &data->fattr);
  4003. else
  4004. nfs_refresh_inode(inode, &data->fattr);
  4005. out:
  4006. rpc_put_task(task);
  4007. return status;
  4008. }
  4009. int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
  4010. {
  4011. struct nfs_server *server = NFS_SERVER(inode);
  4012. struct nfs4_exception exception = { };
  4013. int err;
  4014. do {
  4015. err = _nfs4_proc_delegreturn(inode, cred, stateid, issync);
  4016. switch (err) {
  4017. case -NFS4ERR_STALE_STATEID:
  4018. case -NFS4ERR_EXPIRED:
  4019. case 0:
  4020. return 0;
  4021. }
  4022. err = nfs4_handle_exception(server, err, &exception);
  4023. } while (exception.retry);
  4024. return err;
  4025. }
  4026. #define NFS4_LOCK_MINTIMEOUT (1 * HZ)
  4027. #define NFS4_LOCK_MAXTIMEOUT (30 * HZ)
  4028. /*
  4029. * sleep, with exponential backoff, and retry the LOCK operation.
  4030. */
  4031. static unsigned long
  4032. nfs4_set_lock_task_retry(unsigned long timeout)
  4033. {
  4034. freezable_schedule_timeout_killable(timeout);
  4035. timeout <<= 1;
  4036. if (timeout > NFS4_LOCK_MAXTIMEOUT)
  4037. return NFS4_LOCK_MAXTIMEOUT;
  4038. return timeout;
  4039. }
  4040. static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
  4041. {
  4042. struct inode *inode = state->inode;
  4043. struct nfs_server *server = NFS_SERVER(inode);
  4044. struct nfs_client *clp = server->nfs_client;
  4045. struct nfs_lockt_args arg = {
  4046. .fh = NFS_FH(inode),
  4047. .fl = request,
  4048. };
  4049. struct nfs_lockt_res res = {
  4050. .denied = request,
  4051. };
  4052. struct rpc_message msg = {
  4053. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKT],
  4054. .rpc_argp = &arg,
  4055. .rpc_resp = &res,
  4056. .rpc_cred = state->owner->so_cred,
  4057. };
  4058. struct nfs4_lock_state *lsp;
  4059. int status;
  4060. arg.lock_owner.clientid = clp->cl_clientid;
  4061. status = nfs4_set_lock_state(state, request);
  4062. if (status != 0)
  4063. goto out;
  4064. lsp = request->fl_u.nfs4_fl.owner;
  4065. arg.lock_owner.id = lsp->ls_seqid.owner_id;
  4066. arg.lock_owner.s_dev = server->s_dev;
  4067. status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
  4068. switch (status) {
  4069. case 0:
  4070. request->fl_type = F_UNLCK;
  4071. break;
  4072. case -NFS4ERR_DENIED:
  4073. status = 0;
  4074. }
  4075. request->fl_ops->fl_release_private(request);
  4076. out:
  4077. return status;
  4078. }
  4079. static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
  4080. {
  4081. struct nfs4_exception exception = { };
  4082. int err;
  4083. do {
  4084. err = nfs4_handle_exception(NFS_SERVER(state->inode),
  4085. _nfs4_proc_getlk(state, cmd, request),
  4086. &exception);
  4087. } while (exception.retry);
  4088. return err;
  4089. }
  4090. static int do_vfs_lock(struct file *file, struct file_lock *fl)
  4091. {
  4092. int res = 0;
  4093. switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
  4094. case FL_POSIX:
  4095. res = posix_lock_file_wait(file, fl);
  4096. break;
  4097. case FL_FLOCK:
  4098. res = flock_lock_file_wait(file, fl);
  4099. break;
  4100. default:
  4101. BUG();
  4102. }
  4103. return res;
  4104. }
  4105. struct nfs4_unlockdata {
  4106. struct nfs_locku_args arg;
  4107. struct nfs_locku_res res;
  4108. struct nfs4_lock_state *lsp;
  4109. struct nfs_open_context *ctx;
  4110. struct file_lock fl;
  4111. const struct nfs_server *server;
  4112. unsigned long timestamp;
  4113. };
  4114. static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,
  4115. struct nfs_open_context *ctx,
  4116. struct nfs4_lock_state *lsp,
  4117. struct nfs_seqid *seqid)
  4118. {
  4119. struct nfs4_unlockdata *p;
  4120. struct inode *inode = lsp->ls_state->inode;
  4121. p = kzalloc(sizeof(*p), GFP_NOFS);
  4122. if (p == NULL)
  4123. return NULL;
  4124. p->arg.fh = NFS_FH(inode);
  4125. p->arg.fl = &p->fl;
  4126. p->arg.seqid = seqid;
  4127. p->res.seqid = seqid;
  4128. p->arg.stateid = &lsp->ls_stateid;
  4129. p->lsp = lsp;
  4130. atomic_inc(&lsp->ls_count);
  4131. /* Ensure we don't close file until we're done freeing locks! */
  4132. p->ctx = get_nfs_open_context(ctx);
  4133. memcpy(&p->fl, fl, sizeof(p->fl));
  4134. p->server = NFS_SERVER(inode);
  4135. return p;
  4136. }
  4137. static void nfs4_locku_release_calldata(void *data)
  4138. {
  4139. struct nfs4_unlockdata *calldata = data;
  4140. nfs_free_seqid(calldata->arg.seqid);
  4141. nfs4_put_lock_state(calldata->lsp);
  4142. put_nfs_open_context(calldata->ctx);
  4143. kfree(calldata);
  4144. }
  4145. static void nfs4_locku_done(struct rpc_task *task, void *data)
  4146. {
  4147. struct nfs4_unlockdata *calldata = data;
  4148. if (!nfs4_sequence_done(task, &calldata->res.seq_res))
  4149. return;
  4150. switch (task->tk_status) {
  4151. case 0:
  4152. nfs4_stateid_copy(&calldata->lsp->ls_stateid,
  4153. &calldata->res.stateid);
  4154. renew_lease(calldata->server, calldata->timestamp);
  4155. break;
  4156. case -NFS4ERR_BAD_STATEID:
  4157. case -NFS4ERR_OLD_STATEID:
  4158. case -NFS4ERR_STALE_STATEID:
  4159. case -NFS4ERR_EXPIRED:
  4160. break;
  4161. default:
  4162. if (nfs4_async_handle_error(task, calldata->server, NULL) == -EAGAIN)
  4163. rpc_restart_call_prepare(task);
  4164. }
  4165. nfs_release_seqid(calldata->arg.seqid);
  4166. }
  4167. static void nfs4_locku_prepare(struct rpc_task *task, void *data)
  4168. {
  4169. struct nfs4_unlockdata *calldata = data;
  4170. if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
  4171. goto out_wait;
  4172. if (test_bit(NFS_LOCK_INITIALIZED, &calldata->lsp->ls_flags) == 0) {
  4173. /* Note: exit _without_ running nfs4_locku_done */
  4174. goto out_no_action;
  4175. }
  4176. calldata->timestamp = jiffies;
  4177. if (nfs4_setup_sequence(calldata->server,
  4178. &calldata->arg.seq_args,
  4179. &calldata->res.seq_res,
  4180. task) != 0)
  4181. nfs_release_seqid(calldata->arg.seqid);
  4182. return;
  4183. out_no_action:
  4184. task->tk_action = NULL;
  4185. out_wait:
  4186. nfs4_sequence_done(task, &calldata->res.seq_res);
  4187. }
  4188. static const struct rpc_call_ops nfs4_locku_ops = {
  4189. .rpc_call_prepare = nfs4_locku_prepare,
  4190. .rpc_call_done = nfs4_locku_done,
  4191. .rpc_release = nfs4_locku_release_calldata,
  4192. };
  4193. static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
  4194. struct nfs_open_context *ctx,
  4195. struct nfs4_lock_state *lsp,
  4196. struct nfs_seqid *seqid)
  4197. {
  4198. struct nfs4_unlockdata *data;
  4199. struct rpc_message msg = {
  4200. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU],
  4201. .rpc_cred = ctx->cred,
  4202. };
  4203. struct rpc_task_setup task_setup_data = {
  4204. .rpc_client = NFS_CLIENT(lsp->ls_state->inode),
  4205. .rpc_message = &msg,
  4206. .callback_ops = &nfs4_locku_ops,
  4207. .workqueue = nfsiod_workqueue,
  4208. .flags = RPC_TASK_ASYNC,
  4209. };
  4210. /* Ensure this is an unlock - when canceling a lock, the
  4211. * canceled lock is passed in, and it won't be an unlock.
  4212. */
  4213. fl->fl_type = F_UNLCK;
  4214. data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid);
  4215. if (data == NULL) {
  4216. nfs_free_seqid(seqid);
  4217. return ERR_PTR(-ENOMEM);
  4218. }
  4219. nfs41_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1);
  4220. msg.rpc_argp = &data->arg;
  4221. msg.rpc_resp = &data->res;
  4222. task_setup_data.callback_data = data;
  4223. return rpc_run_task(&task_setup_data);
  4224. }
  4225. static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request)
  4226. {
  4227. struct inode *inode = state->inode;
  4228. struct nfs4_state_owner *sp = state->owner;
  4229. struct nfs_inode *nfsi = NFS_I(inode);
  4230. struct nfs_seqid *seqid;
  4231. struct nfs4_lock_state *lsp;
  4232. struct rpc_task *task;
  4233. int status = 0;
  4234. unsigned char fl_flags = request->fl_flags;
  4235. status = nfs4_set_lock_state(state, request);
  4236. /* Unlock _before_ we do the RPC call */
  4237. request->fl_flags |= FL_EXISTS;
  4238. /* Exclude nfs_delegation_claim_locks() */
  4239. mutex_lock(&sp->so_delegreturn_mutex);
  4240. /* Exclude nfs4_reclaim_open_stateid() - note nesting! */
  4241. down_read(&nfsi->rwsem);
  4242. if (do_vfs_lock(request->fl_file, request) == -ENOENT) {
  4243. up_read(&nfsi->rwsem);
  4244. mutex_unlock(&sp->so_delegreturn_mutex);
  4245. goto out;
  4246. }
  4247. up_read(&nfsi->rwsem);
  4248. mutex_unlock(&sp->so_delegreturn_mutex);
  4249. if (status != 0)
  4250. goto out;
  4251. /* Is this a delegated lock? */
  4252. if (test_bit(NFS_DELEGATED_STATE, &state->flags))
  4253. goto out;
  4254. lsp = request->fl_u.nfs4_fl.owner;
  4255. seqid = nfs_alloc_seqid(&lsp->ls_seqid, GFP_KERNEL);
  4256. status = -ENOMEM;
  4257. if (seqid == NULL)
  4258. goto out;
  4259. task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid);
  4260. status = PTR_ERR(task);
  4261. if (IS_ERR(task))
  4262. goto out;
  4263. status = nfs4_wait_for_completion_rpc_task(task);
  4264. rpc_put_task(task);
  4265. out:
  4266. request->fl_flags = fl_flags;
  4267. return status;
  4268. }
  4269. struct nfs4_lockdata {
  4270. struct nfs_lock_args arg;
  4271. struct nfs_lock_res res;
  4272. struct nfs4_lock_state *lsp;
  4273. struct nfs_open_context *ctx;
  4274. struct file_lock fl;
  4275. unsigned long timestamp;
  4276. int rpc_status;
  4277. int cancelled;
  4278. struct nfs_server *server;
  4279. };
  4280. static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl,
  4281. struct nfs_open_context *ctx, struct nfs4_lock_state *lsp,
  4282. gfp_t gfp_mask)
  4283. {
  4284. struct nfs4_lockdata *p;
  4285. struct inode *inode = lsp->ls_state->inode;
  4286. struct nfs_server *server = NFS_SERVER(inode);
  4287. p = kzalloc(sizeof(*p), gfp_mask);
  4288. if (p == NULL)
  4289. return NULL;
  4290. p->arg.fh = NFS_FH(inode);
  4291. p->arg.fl = &p->fl;
  4292. p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid, gfp_mask);
  4293. if (p->arg.open_seqid == NULL)
  4294. goto out_free;
  4295. p->arg.lock_seqid = nfs_alloc_seqid(&lsp->ls_seqid, gfp_mask);
  4296. if (p->arg.lock_seqid == NULL)
  4297. goto out_free_seqid;
  4298. p->arg.lock_stateid = &lsp->ls_stateid;
  4299. p->arg.lock_owner.clientid = server->nfs_client->cl_clientid;
  4300. p->arg.lock_owner.id = lsp->ls_seqid.owner_id;
  4301. p->arg.lock_owner.s_dev = server->s_dev;
  4302. p->res.lock_seqid = p->arg.lock_seqid;
  4303. p->lsp = lsp;
  4304. p->server = server;
  4305. atomic_inc(&lsp->ls_count);
  4306. p->ctx = get_nfs_open_context(ctx);
  4307. memcpy(&p->fl, fl, sizeof(p->fl));
  4308. return p;
  4309. out_free_seqid:
  4310. nfs_free_seqid(p->arg.open_seqid);
  4311. out_free:
  4312. kfree(p);
  4313. return NULL;
  4314. }
  4315. static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
  4316. {
  4317. struct nfs4_lockdata *data = calldata;
  4318. struct nfs4_state *state = data->lsp->ls_state;
  4319. dprintk("%s: begin!\n", __func__);
  4320. if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)
  4321. goto out_wait;
  4322. /* Do we need to do an open_to_lock_owner? */
  4323. if (!(data->arg.lock_seqid->sequence->flags & NFS_SEQID_CONFIRMED)) {
  4324. if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) {
  4325. goto out_release_lock_seqid;
  4326. }
  4327. data->arg.open_stateid = &state->open_stateid;
  4328. data->arg.new_lock_owner = 1;
  4329. data->res.open_seqid = data->arg.open_seqid;
  4330. } else
  4331. data->arg.new_lock_owner = 0;
  4332. if (!nfs4_valid_open_stateid(state)) {
  4333. data->rpc_status = -EBADF;
  4334. task->tk_action = NULL;
  4335. goto out_release_open_seqid;
  4336. }
  4337. data->timestamp = jiffies;
  4338. if (nfs4_setup_sequence(data->server,
  4339. &data->arg.seq_args,
  4340. &data->res.seq_res,
  4341. task) == 0)
  4342. return;
  4343. out_release_open_seqid:
  4344. nfs_release_seqid(data->arg.open_seqid);
  4345. out_release_lock_seqid:
  4346. nfs_release_seqid(data->arg.lock_seqid);
  4347. out_wait:
  4348. nfs4_sequence_done(task, &data->res.seq_res);
  4349. dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status);
  4350. }
  4351. static void nfs4_lock_done(struct rpc_task *task, void *calldata)
  4352. {
  4353. struct nfs4_lockdata *data = calldata;
  4354. dprintk("%s: begin!\n", __func__);
  4355. if (!nfs4_sequence_done(task, &data->res.seq_res))
  4356. return;
  4357. data->rpc_status = task->tk_status;
  4358. if (data->arg.new_lock_owner != 0) {
  4359. if (data->rpc_status == 0)
  4360. nfs_confirm_seqid(&data->lsp->ls_seqid, 0);
  4361. else
  4362. goto out;
  4363. }
  4364. if (data->rpc_status == 0) {
  4365. nfs4_stateid_copy(&data->lsp->ls_stateid, &data->res.stateid);
  4366. set_bit(NFS_LOCK_INITIALIZED, &data->lsp->ls_flags);
  4367. renew_lease(NFS_SERVER(data->ctx->dentry->d_inode), data->timestamp);
  4368. }
  4369. out:
  4370. dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status);
  4371. }
  4372. static void nfs4_lock_release(void *calldata)
  4373. {
  4374. struct nfs4_lockdata *data = calldata;
  4375. dprintk("%s: begin!\n", __func__);
  4376. nfs_free_seqid(data->arg.open_seqid);
  4377. if (data->cancelled != 0) {
  4378. struct rpc_task *task;
  4379. task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp,
  4380. data->arg.lock_seqid);
  4381. if (!IS_ERR(task))
  4382. rpc_put_task_async(task);
  4383. dprintk("%s: cancelling lock!\n", __func__);
  4384. } else
  4385. nfs_free_seqid(data->arg.lock_seqid);
  4386. nfs4_put_lock_state(data->lsp);
  4387. put_nfs_open_context(data->ctx);
  4388. kfree(data);
  4389. dprintk("%s: done!\n", __func__);
  4390. }
  4391. static const struct rpc_call_ops nfs4_lock_ops = {
  4392. .rpc_call_prepare = nfs4_lock_prepare,
  4393. .rpc_call_done = nfs4_lock_done,
  4394. .rpc_release = nfs4_lock_release,
  4395. };
  4396. static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new_lock_owner, int error)
  4397. {
  4398. switch (error) {
  4399. case -NFS4ERR_ADMIN_REVOKED:
  4400. case -NFS4ERR_BAD_STATEID:
  4401. lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
  4402. if (new_lock_owner != 0 ||
  4403. test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0)
  4404. nfs4_schedule_stateid_recovery(server, lsp->ls_state);
  4405. break;
  4406. case -NFS4ERR_STALE_STATEID:
  4407. lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
  4408. case -NFS4ERR_EXPIRED:
  4409. nfs4_schedule_lease_recovery(server->nfs_client);
  4410. };
  4411. }
  4412. static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type)
  4413. {
  4414. struct nfs4_lockdata *data;
  4415. struct rpc_task *task;
  4416. struct rpc_message msg = {
  4417. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK],
  4418. .rpc_cred = state->owner->so_cred,
  4419. };
  4420. struct rpc_task_setup task_setup_data = {
  4421. .rpc_client = NFS_CLIENT(state->inode),
  4422. .rpc_message = &msg,
  4423. .callback_ops = &nfs4_lock_ops,
  4424. .workqueue = nfsiod_workqueue,
  4425. .flags = RPC_TASK_ASYNC,
  4426. };
  4427. int ret;
  4428. dprintk("%s: begin!\n", __func__);
  4429. data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file),
  4430. fl->fl_u.nfs4_fl.owner,
  4431. recovery_type == NFS_LOCK_NEW ? GFP_KERNEL : GFP_NOFS);
  4432. if (data == NULL)
  4433. return -ENOMEM;
  4434. if (IS_SETLKW(cmd))
  4435. data->arg.block = 1;
  4436. nfs41_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1);
  4437. msg.rpc_argp = &data->arg;
  4438. msg.rpc_resp = &data->res;
  4439. task_setup_data.callback_data = data;
  4440. if (recovery_type > NFS_LOCK_NEW) {
  4441. if (recovery_type == NFS_LOCK_RECLAIM)
  4442. data->arg.reclaim = NFS_LOCK_RECLAIM;
  4443. nfs4_set_sequence_privileged(&data->arg.seq_args);
  4444. }
  4445. task = rpc_run_task(&task_setup_data);
  4446. if (IS_ERR(task))
  4447. return PTR_ERR(task);
  4448. ret = nfs4_wait_for_completion_rpc_task(task);
  4449. if (ret == 0) {
  4450. ret = data->rpc_status;
  4451. if (ret)
  4452. nfs4_handle_setlk_error(data->server, data->lsp,
  4453. data->arg.new_lock_owner, ret);
  4454. } else
  4455. data->cancelled = 1;
  4456. rpc_put_task(task);
  4457. dprintk("%s: done, ret = %d!\n", __func__, ret);
  4458. return ret;
  4459. }
  4460. static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request)
  4461. {
  4462. struct nfs_server *server = NFS_SERVER(state->inode);
  4463. struct nfs4_exception exception = {
  4464. .inode = state->inode,
  4465. };
  4466. int err;
  4467. do {
  4468. /* Cache the lock if possible... */
  4469. if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
  4470. return 0;
  4471. err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_RECLAIM);
  4472. if (err != -NFS4ERR_DELAY)
  4473. break;
  4474. nfs4_handle_exception(server, err, &exception);
  4475. } while (exception.retry);
  4476. return err;
  4477. }
  4478. static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request)
  4479. {
  4480. struct nfs_server *server = NFS_SERVER(state->inode);
  4481. struct nfs4_exception exception = {
  4482. .inode = state->inode,
  4483. };
  4484. int err;
  4485. err = nfs4_set_lock_state(state, request);
  4486. if (err != 0)
  4487. return err;
  4488. do {
  4489. if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
  4490. return 0;
  4491. err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_EXPIRED);
  4492. switch (err) {
  4493. default:
  4494. goto out;
  4495. case -NFS4ERR_GRACE:
  4496. case -NFS4ERR_DELAY:
  4497. nfs4_handle_exception(server, err, &exception);
  4498. err = 0;
  4499. }
  4500. } while (exception.retry);
  4501. out:
  4502. return err;
  4503. }
  4504. #if defined(CONFIG_NFS_V4_1)
  4505. /**
  4506. * nfs41_check_expired_locks - possibly free a lock stateid
  4507. *
  4508. * @state: NFSv4 state for an inode
  4509. *
  4510. * Returns NFS_OK if recovery for this stateid is now finished.
  4511. * Otherwise a negative NFS4ERR value is returned.
  4512. */
  4513. static int nfs41_check_expired_locks(struct nfs4_state *state)
  4514. {
  4515. int status, ret = -NFS4ERR_BAD_STATEID;
  4516. struct nfs4_lock_state *lsp;
  4517. struct nfs_server *server = NFS_SERVER(state->inode);
  4518. list_for_each_entry(lsp, &state->lock_states, ls_locks) {
  4519. if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
  4520. status = nfs41_test_stateid(server, &lsp->ls_stateid);
  4521. if (status != NFS_OK) {
  4522. /* Free the stateid unless the server
  4523. * informs us the stateid is unrecognized. */
  4524. if (status != -NFS4ERR_BAD_STATEID)
  4525. nfs41_free_stateid(server,
  4526. &lsp->ls_stateid);
  4527. clear_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags);
  4528. ret = status;
  4529. }
  4530. }
  4531. };
  4532. return ret;
  4533. }
  4534. static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *request)
  4535. {
  4536. int status = NFS_OK;
  4537. if (test_bit(LK_STATE_IN_USE, &state->flags))
  4538. status = nfs41_check_expired_locks(state);
  4539. if (status != NFS_OK)
  4540. status = nfs4_lock_expired(state, request);
  4541. return status;
  4542. }
  4543. #endif
  4544. static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
  4545. {
  4546. struct nfs4_state_owner *sp = state->owner;
  4547. struct nfs_inode *nfsi = NFS_I(state->inode);
  4548. unsigned char fl_flags = request->fl_flags;
  4549. unsigned int seq;
  4550. int status = -ENOLCK;
  4551. if ((fl_flags & FL_POSIX) &&
  4552. !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags))
  4553. goto out;
  4554. /* Is this a delegated open? */
  4555. status = nfs4_set_lock_state(state, request);
  4556. if (status != 0)
  4557. goto out;
  4558. request->fl_flags |= FL_ACCESS;
  4559. status = do_vfs_lock(request->fl_file, request);
  4560. if (status < 0)
  4561. goto out;
  4562. down_read(&nfsi->rwsem);
  4563. if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {
  4564. /* Yes: cache locks! */
  4565. /* ...but avoid races with delegation recall... */
  4566. request->fl_flags = fl_flags & ~FL_SLEEP;
  4567. status = do_vfs_lock(request->fl_file, request);
  4568. goto out_unlock;
  4569. }
  4570. seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
  4571. up_read(&nfsi->rwsem);
  4572. status = _nfs4_do_setlk(state, cmd, request, NFS_LOCK_NEW);
  4573. if (status != 0)
  4574. goto out;
  4575. down_read(&nfsi->rwsem);
  4576. if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq)) {
  4577. status = -NFS4ERR_DELAY;
  4578. goto out_unlock;
  4579. }
  4580. /* Note: we always want to sleep here! */
  4581. request->fl_flags = fl_flags | FL_SLEEP;
  4582. if (do_vfs_lock(request->fl_file, request) < 0)
  4583. printk(KERN_WARNING "NFS: %s: VFS is out of sync with lock "
  4584. "manager!\n", __func__);
  4585. out_unlock:
  4586. up_read(&nfsi->rwsem);
  4587. out:
  4588. request->fl_flags = fl_flags;
  4589. return status;
  4590. }
  4591. static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
  4592. {
  4593. struct nfs4_exception exception = {
  4594. .state = state,
  4595. .inode = state->inode,
  4596. };
  4597. int err;
  4598. do {
  4599. err = _nfs4_proc_setlk(state, cmd, request);
  4600. if (err == -NFS4ERR_DENIED)
  4601. err = -EAGAIN;
  4602. err = nfs4_handle_exception(NFS_SERVER(state->inode),
  4603. err, &exception);
  4604. } while (exception.retry);
  4605. return err;
  4606. }
  4607. static int
  4608. nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request)
  4609. {
  4610. struct nfs_open_context *ctx;
  4611. struct nfs4_state *state;
  4612. unsigned long timeout = NFS4_LOCK_MINTIMEOUT;
  4613. int status;
  4614. /* verify open state */
  4615. ctx = nfs_file_open_context(filp);
  4616. state = ctx->state;
  4617. if (request->fl_start < 0 || request->fl_end < 0)
  4618. return -EINVAL;
  4619. if (IS_GETLK(cmd)) {
  4620. if (state != NULL)
  4621. return nfs4_proc_getlk(state, F_GETLK, request);
  4622. return 0;
  4623. }
  4624. if (!(IS_SETLK(cmd) || IS_SETLKW(cmd)))
  4625. return -EINVAL;
  4626. if (request->fl_type == F_UNLCK) {
  4627. if (state != NULL)
  4628. return nfs4_proc_unlck(state, cmd, request);
  4629. return 0;
  4630. }
  4631. if (state == NULL)
  4632. return -ENOLCK;
  4633. /*
  4634. * Don't rely on the VFS having checked the file open mode,
  4635. * since it won't do this for flock() locks.
  4636. */
  4637. switch (request->fl_type) {
  4638. case F_RDLCK:
  4639. if (!(filp->f_mode & FMODE_READ))
  4640. return -EBADF;
  4641. break;
  4642. case F_WRLCK:
  4643. if (!(filp->f_mode & FMODE_WRITE))
  4644. return -EBADF;
  4645. }
  4646. do {
  4647. status = nfs4_proc_setlk(state, cmd, request);
  4648. if ((status != -EAGAIN) || IS_SETLK(cmd))
  4649. break;
  4650. timeout = nfs4_set_lock_task_retry(timeout);
  4651. status = -ERESTARTSYS;
  4652. if (signalled())
  4653. break;
  4654. } while(status < 0);
  4655. return status;
  4656. }
  4657. int nfs4_lock_delegation_recall(struct file_lock *fl, struct nfs4_state *state, const nfs4_stateid *stateid)
  4658. {
  4659. struct nfs_server *server = NFS_SERVER(state->inode);
  4660. int err;
  4661. err = nfs4_set_lock_state(state, fl);
  4662. if (err != 0)
  4663. return err;
  4664. err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW);
  4665. return nfs4_handle_delegation_recall_error(server, state, stateid, err);
  4666. }
  4667. struct nfs_release_lockowner_data {
  4668. struct nfs4_lock_state *lsp;
  4669. struct nfs_server *server;
  4670. struct nfs_release_lockowner_args args;
  4671. };
  4672. static void nfs4_release_lockowner_release(void *calldata)
  4673. {
  4674. struct nfs_release_lockowner_data *data = calldata;
  4675. nfs4_free_lock_state(data->server, data->lsp);
  4676. kfree(calldata);
  4677. }
  4678. static const struct rpc_call_ops nfs4_release_lockowner_ops = {
  4679. .rpc_release = nfs4_release_lockowner_release,
  4680. };
  4681. int nfs4_release_lockowner(struct nfs4_lock_state *lsp)
  4682. {
  4683. struct nfs_server *server = lsp->ls_state->owner->so_server;
  4684. struct nfs_release_lockowner_data *data;
  4685. struct rpc_message msg = {
  4686. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RELEASE_LOCKOWNER],
  4687. };
  4688. if (server->nfs_client->cl_mvops->minor_version != 0)
  4689. return -EINVAL;
  4690. data = kmalloc(sizeof(*data), GFP_NOFS);
  4691. if (!data)
  4692. return -ENOMEM;
  4693. data->lsp = lsp;
  4694. data->server = server;
  4695. data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
  4696. data->args.lock_owner.id = lsp->ls_seqid.owner_id;
  4697. data->args.lock_owner.s_dev = server->s_dev;
  4698. msg.rpc_argp = &data->args;
  4699. rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, data);
  4700. return 0;
  4701. }
  4702. #define XATTR_NAME_NFSV4_ACL "system.nfs4_acl"
  4703. static int nfs4_xattr_set_nfs4_acl(struct dentry *dentry, const char *key,
  4704. const void *buf, size_t buflen,
  4705. int flags, int type)
  4706. {
  4707. if (strcmp(key, "") != 0)
  4708. return -EINVAL;
  4709. return nfs4_proc_set_acl(dentry->d_inode, buf, buflen);
  4710. }
  4711. static int nfs4_xattr_get_nfs4_acl(struct dentry *dentry, const char *key,
  4712. void *buf, size_t buflen, int type)
  4713. {
  4714. if (strcmp(key, "") != 0)
  4715. return -EINVAL;
  4716. return nfs4_proc_get_acl(dentry->d_inode, buf, buflen);
  4717. }
  4718. static size_t nfs4_xattr_list_nfs4_acl(struct dentry *dentry, char *list,
  4719. size_t list_len, const char *name,
  4720. size_t name_len, int type)
  4721. {
  4722. size_t len = sizeof(XATTR_NAME_NFSV4_ACL);
  4723. if (!nfs4_server_supports_acls(NFS_SERVER(dentry->d_inode)))
  4724. return 0;
  4725. if (list && len <= list_len)
  4726. memcpy(list, XATTR_NAME_NFSV4_ACL, len);
  4727. return len;
  4728. }
  4729. /*
  4730. * nfs_fhget will use either the mounted_on_fileid or the fileid
  4731. */
  4732. static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr)
  4733. {
  4734. if (!(((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) ||
  4735. (fattr->valid & NFS_ATTR_FATTR_FILEID)) &&
  4736. (fattr->valid & NFS_ATTR_FATTR_FSID) &&
  4737. (fattr->valid & NFS_ATTR_FATTR_V4_LOCATIONS)))
  4738. return;
  4739. fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
  4740. NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_V4_REFERRAL;
  4741. fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
  4742. fattr->nlink = 2;
  4743. }
  4744. static int _nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
  4745. const struct qstr *name,
  4746. struct nfs4_fs_locations *fs_locations,
  4747. struct page *page)
  4748. {
  4749. struct nfs_server *server = NFS_SERVER(dir);
  4750. u32 bitmask[2] = {
  4751. [0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
  4752. };
  4753. struct nfs4_fs_locations_arg args = {
  4754. .dir_fh = NFS_FH(dir),
  4755. .name = name,
  4756. .page = page,
  4757. .bitmask = bitmask,
  4758. };
  4759. struct nfs4_fs_locations_res res = {
  4760. .fs_locations = fs_locations,
  4761. };
  4762. struct rpc_message msg = {
  4763. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
  4764. .rpc_argp = &args,
  4765. .rpc_resp = &res,
  4766. };
  4767. int status;
  4768. dprintk("%s: start\n", __func__);
  4769. /* Ask for the fileid of the absent filesystem if mounted_on_fileid
  4770. * is not supported */
  4771. if (NFS_SERVER(dir)->attr_bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)
  4772. bitmask[1] |= FATTR4_WORD1_MOUNTED_ON_FILEID;
  4773. else
  4774. bitmask[0] |= FATTR4_WORD0_FILEID;
  4775. nfs_fattr_init(&fs_locations->fattr);
  4776. fs_locations->server = server;
  4777. fs_locations->nlocations = 0;
  4778. status = nfs4_call_sync(client, server, &msg, &args.seq_args, &res.seq_res, 0);
  4779. dprintk("%s: returned status = %d\n", __func__, status);
  4780. return status;
  4781. }
  4782. int nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
  4783. const struct qstr *name,
  4784. struct nfs4_fs_locations *fs_locations,
  4785. struct page *page)
  4786. {
  4787. struct nfs4_exception exception = { };
  4788. int err;
  4789. do {
  4790. err = nfs4_handle_exception(NFS_SERVER(dir),
  4791. _nfs4_proc_fs_locations(client, dir, name, fs_locations, page),
  4792. &exception);
  4793. } while (exception.retry);
  4794. return err;
  4795. }
  4796. static int _nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct nfs4_secinfo_flavors *flavors)
  4797. {
  4798. int status;
  4799. struct nfs4_secinfo_arg args = {
  4800. .dir_fh = NFS_FH(dir),
  4801. .name = name,
  4802. };
  4803. struct nfs4_secinfo_res res = {
  4804. .flavors = flavors,
  4805. };
  4806. struct rpc_message msg = {
  4807. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO],
  4808. .rpc_argp = &args,
  4809. .rpc_resp = &res,
  4810. };
  4811. dprintk("NFS call secinfo %s\n", name->name);
  4812. status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &msg, &args.seq_args, &res.seq_res, 0);
  4813. dprintk("NFS reply secinfo: %d\n", status);
  4814. return status;
  4815. }
  4816. int nfs4_proc_secinfo(struct inode *dir, const struct qstr *name,
  4817. struct nfs4_secinfo_flavors *flavors)
  4818. {
  4819. struct nfs4_exception exception = { };
  4820. int err;
  4821. do {
  4822. err = nfs4_handle_exception(NFS_SERVER(dir),
  4823. _nfs4_proc_secinfo(dir, name, flavors),
  4824. &exception);
  4825. } while (exception.retry);
  4826. return err;
  4827. }
  4828. #ifdef CONFIG_NFS_V4_1
  4829. /*
  4830. * Check the exchange flags returned by the server for invalid flags, having
  4831. * both PNFS and NON_PNFS flags set, and not having one of NON_PNFS, PNFS, or
  4832. * DS flags set.
  4833. */
  4834. static int nfs4_check_cl_exchange_flags(u32 flags)
  4835. {
  4836. if (flags & ~EXCHGID4_FLAG_MASK_R)
  4837. goto out_inval;
  4838. if ((flags & EXCHGID4_FLAG_USE_PNFS_MDS) &&
  4839. (flags & EXCHGID4_FLAG_USE_NON_PNFS))
  4840. goto out_inval;
  4841. if (!(flags & (EXCHGID4_FLAG_MASK_PNFS)))
  4842. goto out_inval;
  4843. return NFS_OK;
  4844. out_inval:
  4845. return -NFS4ERR_INVAL;
  4846. }
  4847. static bool
  4848. nfs41_same_server_scope(struct nfs41_server_scope *a,
  4849. struct nfs41_server_scope *b)
  4850. {
  4851. if (a->server_scope_sz == b->server_scope_sz &&
  4852. memcmp(a->server_scope, b->server_scope, a->server_scope_sz) == 0)
  4853. return true;
  4854. return false;
  4855. }
  4856. /*
  4857. * nfs4_proc_bind_conn_to_session()
  4858. *
  4859. * The 4.1 client currently uses the same TCP connection for the
  4860. * fore and backchannel.
  4861. */
  4862. int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, struct rpc_cred *cred)
  4863. {
  4864. int status;
  4865. struct nfs41_bind_conn_to_session_res res;
  4866. struct rpc_message msg = {
  4867. .rpc_proc =
  4868. &nfs4_procedures[NFSPROC4_CLNT_BIND_CONN_TO_SESSION],
  4869. .rpc_argp = clp,
  4870. .rpc_resp = &res,
  4871. .rpc_cred = cred,
  4872. };
  4873. dprintk("--> %s\n", __func__);
  4874. res.session = kzalloc(sizeof(struct nfs4_session), GFP_NOFS);
  4875. if (unlikely(res.session == NULL)) {
  4876. status = -ENOMEM;
  4877. goto out;
  4878. }
  4879. status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
  4880. if (status == 0) {
  4881. if (memcmp(res.session->sess_id.data,
  4882. clp->cl_session->sess_id.data, NFS4_MAX_SESSIONID_LEN)) {
  4883. dprintk("NFS: %s: Session ID mismatch\n", __func__);
  4884. status = -EIO;
  4885. goto out_session;
  4886. }
  4887. if (res.dir != NFS4_CDFS4_BOTH) {
  4888. dprintk("NFS: %s: Unexpected direction from server\n",
  4889. __func__);
  4890. status = -EIO;
  4891. goto out_session;
  4892. }
  4893. if (res.use_conn_in_rdma_mode) {
  4894. dprintk("NFS: %s: Server returned RDMA mode = true\n",
  4895. __func__);
  4896. status = -EIO;
  4897. goto out_session;
  4898. }
  4899. }
  4900. out_session:
  4901. kfree(res.session);
  4902. out:
  4903. dprintk("<-- %s status= %d\n", __func__, status);
  4904. return status;
  4905. }
  4906. /*
  4907. * nfs4_proc_exchange_id()
  4908. *
  4909. * Returns zero, a negative errno, or a negative NFS4ERR status code.
  4910. *
  4911. * Since the clientid has expired, all compounds using sessions
  4912. * associated with the stale clientid will be returning
  4913. * NFS4ERR_BADSESSION in the sequence operation, and will therefore
  4914. * be in some phase of session reset.
  4915. */
  4916. int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
  4917. {
  4918. nfs4_verifier verifier;
  4919. struct nfs41_exchange_id_args args = {
  4920. .verifier = &verifier,
  4921. .client = clp,
  4922. .flags = EXCHGID4_FLAG_SUPP_MOVED_REFER,
  4923. };
  4924. struct nfs41_exchange_id_res res = {
  4925. 0
  4926. };
  4927. int status;
  4928. struct rpc_message msg = {
  4929. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_EXCHANGE_ID],
  4930. .rpc_argp = &args,
  4931. .rpc_resp = &res,
  4932. .rpc_cred = cred,
  4933. };
  4934. nfs4_init_boot_verifier(clp, &verifier);
  4935. args.id_len = nfs4_init_uniform_client_string(clp, args.id,
  4936. sizeof(args.id));
  4937. dprintk("NFS call exchange_id auth=%s, '%.*s'\n",
  4938. clp->cl_rpcclient->cl_auth->au_ops->au_name,
  4939. args.id_len, args.id);
  4940. res.server_owner = kzalloc(sizeof(struct nfs41_server_owner),
  4941. GFP_NOFS);
  4942. if (unlikely(res.server_owner == NULL)) {
  4943. status = -ENOMEM;
  4944. goto out;
  4945. }
  4946. res.server_scope = kzalloc(sizeof(struct nfs41_server_scope),
  4947. GFP_NOFS);
  4948. if (unlikely(res.server_scope == NULL)) {
  4949. status = -ENOMEM;
  4950. goto out_server_owner;
  4951. }
  4952. res.impl_id = kzalloc(sizeof(struct nfs41_impl_id), GFP_NOFS);
  4953. if (unlikely(res.impl_id == NULL)) {
  4954. status = -ENOMEM;
  4955. goto out_server_scope;
  4956. }
  4957. status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
  4958. if (status == 0)
  4959. status = nfs4_check_cl_exchange_flags(res.flags);
  4960. if (status == 0) {
  4961. clp->cl_clientid = res.clientid;
  4962. clp->cl_exchange_flags = (res.flags & ~EXCHGID4_FLAG_CONFIRMED_R);
  4963. if (!(res.flags & EXCHGID4_FLAG_CONFIRMED_R))
  4964. clp->cl_seqid = res.seqid;
  4965. kfree(clp->cl_serverowner);
  4966. clp->cl_serverowner = res.server_owner;
  4967. res.server_owner = NULL;
  4968. /* use the most recent implementation id */
  4969. kfree(clp->cl_implid);
  4970. clp->cl_implid = res.impl_id;
  4971. if (clp->cl_serverscope != NULL &&
  4972. !nfs41_same_server_scope(clp->cl_serverscope,
  4973. res.server_scope)) {
  4974. dprintk("%s: server_scope mismatch detected\n",
  4975. __func__);
  4976. set_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state);
  4977. kfree(clp->cl_serverscope);
  4978. clp->cl_serverscope = NULL;
  4979. }
  4980. if (clp->cl_serverscope == NULL) {
  4981. clp->cl_serverscope = res.server_scope;
  4982. goto out;
  4983. }
  4984. } else
  4985. kfree(res.impl_id);
  4986. out_server_owner:
  4987. kfree(res.server_owner);
  4988. out_server_scope:
  4989. kfree(res.server_scope);
  4990. out:
  4991. if (clp->cl_implid != NULL)
  4992. dprintk("NFS reply exchange_id: Server Implementation ID: "
  4993. "domain: %s, name: %s, date: %llu,%u\n",
  4994. clp->cl_implid->domain, clp->cl_implid->name,
  4995. clp->cl_implid->date.seconds,
  4996. clp->cl_implid->date.nseconds);
  4997. dprintk("NFS reply exchange_id: %d\n", status);
  4998. return status;
  4999. }
  5000. static int _nfs4_proc_destroy_clientid(struct nfs_client *clp,
  5001. struct rpc_cred *cred)
  5002. {
  5003. struct rpc_message msg = {
  5004. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_CLIENTID],
  5005. .rpc_argp = clp,
  5006. .rpc_cred = cred,
  5007. };
  5008. int status;
  5009. status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
  5010. if (status)
  5011. dprintk("NFS: Got error %d from the server %s on "
  5012. "DESTROY_CLIENTID.", status, clp->cl_hostname);
  5013. return status;
  5014. }
  5015. static int nfs4_proc_destroy_clientid(struct nfs_client *clp,
  5016. struct rpc_cred *cred)
  5017. {
  5018. unsigned int loop;
  5019. int ret;
  5020. for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {
  5021. ret = _nfs4_proc_destroy_clientid(clp, cred);
  5022. switch (ret) {
  5023. case -NFS4ERR_DELAY:
  5024. case -NFS4ERR_CLIENTID_BUSY:
  5025. ssleep(1);
  5026. break;
  5027. default:
  5028. return ret;
  5029. }
  5030. }
  5031. return 0;
  5032. }
  5033. int nfs4_destroy_clientid(struct nfs_client *clp)
  5034. {
  5035. struct rpc_cred *cred;
  5036. int ret = 0;
  5037. if (clp->cl_mvops->minor_version < 1)
  5038. goto out;
  5039. if (clp->cl_exchange_flags == 0)
  5040. goto out;
  5041. if (clp->cl_preserve_clid)
  5042. goto out;
  5043. cred = nfs4_get_exchange_id_cred(clp);
  5044. ret = nfs4_proc_destroy_clientid(clp, cred);
  5045. if (cred)
  5046. put_rpccred(cred);
  5047. switch (ret) {
  5048. case 0:
  5049. case -NFS4ERR_STALE_CLIENTID:
  5050. clp->cl_exchange_flags = 0;
  5051. }
  5052. out:
  5053. return ret;
  5054. }
  5055. struct nfs4_get_lease_time_data {
  5056. struct nfs4_get_lease_time_args *args;
  5057. struct nfs4_get_lease_time_res *res;
  5058. struct nfs_client *clp;
  5059. };
  5060. static void nfs4_get_lease_time_prepare(struct rpc_task *task,
  5061. void *calldata)
  5062. {
  5063. struct nfs4_get_lease_time_data *data =
  5064. (struct nfs4_get_lease_time_data *)calldata;
  5065. dprintk("--> %s\n", __func__);
  5066. /* just setup sequence, do not trigger session recovery
  5067. since we're invoked within one */
  5068. nfs41_setup_sequence(data->clp->cl_session,
  5069. &data->args->la_seq_args,
  5070. &data->res->lr_seq_res,
  5071. task);
  5072. dprintk("<-- %s\n", __func__);
  5073. }
  5074. /*
  5075. * Called from nfs4_state_manager thread for session setup, so don't recover
  5076. * from sequence operation or clientid errors.
  5077. */
  5078. static void nfs4_get_lease_time_done(struct rpc_task *task, void *calldata)
  5079. {
  5080. struct nfs4_get_lease_time_data *data =
  5081. (struct nfs4_get_lease_time_data *)calldata;
  5082. dprintk("--> %s\n", __func__);
  5083. if (!nfs41_sequence_done(task, &data->res->lr_seq_res))
  5084. return;
  5085. switch (task->tk_status) {
  5086. case -NFS4ERR_DELAY:
  5087. case -NFS4ERR_GRACE:
  5088. dprintk("%s Retry: tk_status %d\n", __func__, task->tk_status);
  5089. rpc_delay(task, NFS4_POLL_RETRY_MIN);
  5090. task->tk_status = 0;
  5091. /* fall through */
  5092. case -NFS4ERR_RETRY_UNCACHED_REP:
  5093. rpc_restart_call_prepare(task);
  5094. return;
  5095. }
  5096. dprintk("<-- %s\n", __func__);
  5097. }
  5098. static const struct rpc_call_ops nfs4_get_lease_time_ops = {
  5099. .rpc_call_prepare = nfs4_get_lease_time_prepare,
  5100. .rpc_call_done = nfs4_get_lease_time_done,
  5101. };
  5102. int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo)
  5103. {
  5104. struct rpc_task *task;
  5105. struct nfs4_get_lease_time_args args;
  5106. struct nfs4_get_lease_time_res res = {
  5107. .lr_fsinfo = fsinfo,
  5108. };
  5109. struct nfs4_get_lease_time_data data = {
  5110. .args = &args,
  5111. .res = &res,
  5112. .clp = clp,
  5113. };
  5114. struct rpc_message msg = {
  5115. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GET_LEASE_TIME],
  5116. .rpc_argp = &args,
  5117. .rpc_resp = &res,
  5118. };
  5119. struct rpc_task_setup task_setup = {
  5120. .rpc_client = clp->cl_rpcclient,
  5121. .rpc_message = &msg,
  5122. .callback_ops = &nfs4_get_lease_time_ops,
  5123. .callback_data = &data,
  5124. .flags = RPC_TASK_TIMEOUT,
  5125. };
  5126. int status;
  5127. nfs41_init_sequence(&args.la_seq_args, &res.lr_seq_res, 0);
  5128. nfs4_set_sequence_privileged(&args.la_seq_args);
  5129. dprintk("--> %s\n", __func__);
  5130. task = rpc_run_task(&task_setup);
  5131. if (IS_ERR(task))
  5132. status = PTR_ERR(task);
  5133. else {
  5134. status = task->tk_status;
  5135. rpc_put_task(task);
  5136. }
  5137. dprintk("<-- %s return %d\n", __func__, status);
  5138. return status;
  5139. }
  5140. /*
  5141. * Initialize the values to be used by the client in CREATE_SESSION
  5142. * If nfs4_init_session set the fore channel request and response sizes,
  5143. * use them.
  5144. *
  5145. * Set the back channel max_resp_sz_cached to zero to force the client to
  5146. * always set csa_cachethis to FALSE because the current implementation
  5147. * of the back channel DRC only supports caching the CB_SEQUENCE operation.
  5148. */
  5149. static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args)
  5150. {
  5151. struct nfs4_session *session = args->client->cl_session;
  5152. unsigned int mxrqst_sz = session->fc_target_max_rqst_sz,
  5153. mxresp_sz = session->fc_target_max_resp_sz;
  5154. if (mxrqst_sz == 0)
  5155. mxrqst_sz = NFS_MAX_FILE_IO_SIZE;
  5156. if (mxresp_sz == 0)
  5157. mxresp_sz = NFS_MAX_FILE_IO_SIZE;
  5158. /* Fore channel attributes */
  5159. args->fc_attrs.max_rqst_sz = mxrqst_sz;
  5160. args->fc_attrs.max_resp_sz = mxresp_sz;
  5161. args->fc_attrs.max_ops = NFS4_MAX_OPS;
  5162. args->fc_attrs.max_reqs = max_session_slots;
  5163. dprintk("%s: Fore Channel : max_rqst_sz=%u max_resp_sz=%u "
  5164. "max_ops=%u max_reqs=%u\n",
  5165. __func__,
  5166. args->fc_attrs.max_rqst_sz, args->fc_attrs.max_resp_sz,
  5167. args->fc_attrs.max_ops, args->fc_attrs.max_reqs);
  5168. /* Back channel attributes */
  5169. args->bc_attrs.max_rqst_sz = PAGE_SIZE;
  5170. args->bc_attrs.max_resp_sz = PAGE_SIZE;
  5171. args->bc_attrs.max_resp_sz_cached = 0;
  5172. args->bc_attrs.max_ops = NFS4_MAX_BACK_CHANNEL_OPS;
  5173. args->bc_attrs.max_reqs = 1;
  5174. dprintk("%s: Back Channel : max_rqst_sz=%u max_resp_sz=%u "
  5175. "max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n",
  5176. __func__,
  5177. args->bc_attrs.max_rqst_sz, args->bc_attrs.max_resp_sz,
  5178. args->bc_attrs.max_resp_sz_cached, args->bc_attrs.max_ops,
  5179. args->bc_attrs.max_reqs);
  5180. }
  5181. static int nfs4_verify_fore_channel_attrs(struct nfs41_create_session_args *args, struct nfs4_session *session)
  5182. {
  5183. struct nfs4_channel_attrs *sent = &args->fc_attrs;
  5184. struct nfs4_channel_attrs *rcvd = &session->fc_attrs;
  5185. if (rcvd->max_resp_sz > sent->max_resp_sz)
  5186. return -EINVAL;
  5187. /*
  5188. * Our requested max_ops is the minimum we need; we're not
  5189. * prepared to break up compounds into smaller pieces than that.
  5190. * So, no point even trying to continue if the server won't
  5191. * cooperate:
  5192. */
  5193. if (rcvd->max_ops < sent->max_ops)
  5194. return -EINVAL;
  5195. if (rcvd->max_reqs == 0)
  5196. return -EINVAL;
  5197. if (rcvd->max_reqs > NFS4_MAX_SLOT_TABLE)
  5198. rcvd->max_reqs = NFS4_MAX_SLOT_TABLE;
  5199. return 0;
  5200. }
  5201. static int nfs4_verify_back_channel_attrs(struct nfs41_create_session_args *args, struct nfs4_session *session)
  5202. {
  5203. struct nfs4_channel_attrs *sent = &args->bc_attrs;
  5204. struct nfs4_channel_attrs *rcvd = &session->bc_attrs;
  5205. if (rcvd->max_rqst_sz > sent->max_rqst_sz)
  5206. return -EINVAL;
  5207. if (rcvd->max_resp_sz < sent->max_resp_sz)
  5208. return -EINVAL;
  5209. if (rcvd->max_resp_sz_cached > sent->max_resp_sz_cached)
  5210. return -EINVAL;
  5211. /* These would render the backchannel useless: */
  5212. if (rcvd->max_ops != sent->max_ops)
  5213. return -EINVAL;
  5214. if (rcvd->max_reqs != sent->max_reqs)
  5215. return -EINVAL;
  5216. return 0;
  5217. }
  5218. static int nfs4_verify_channel_attrs(struct nfs41_create_session_args *args,
  5219. struct nfs4_session *session)
  5220. {
  5221. int ret;
  5222. ret = nfs4_verify_fore_channel_attrs(args, session);
  5223. if (ret)
  5224. return ret;
  5225. return nfs4_verify_back_channel_attrs(args, session);
  5226. }
  5227. static int _nfs4_proc_create_session(struct nfs_client *clp,
  5228. struct rpc_cred *cred)
  5229. {
  5230. struct nfs4_session *session = clp->cl_session;
  5231. struct nfs41_create_session_args args = {
  5232. .client = clp,
  5233. .cb_program = NFS4_CALLBACK,
  5234. };
  5235. struct nfs41_create_session_res res = {
  5236. .client = clp,
  5237. };
  5238. struct rpc_message msg = {
  5239. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE_SESSION],
  5240. .rpc_argp = &args,
  5241. .rpc_resp = &res,
  5242. .rpc_cred = cred,
  5243. };
  5244. int status;
  5245. nfs4_init_channel_attrs(&args);
  5246. args.flags = (SESSION4_PERSIST | SESSION4_BACK_CHAN);
  5247. status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
  5248. if (!status) {
  5249. /* Verify the session's negotiated channel_attrs values */
  5250. status = nfs4_verify_channel_attrs(&args, session);
  5251. /* Increment the clientid slot sequence id */
  5252. clp->cl_seqid++;
  5253. }
  5254. return status;
  5255. }
  5256. /*
  5257. * Issues a CREATE_SESSION operation to the server.
  5258. * It is the responsibility of the caller to verify the session is
  5259. * expired before calling this routine.
  5260. */
  5261. int nfs4_proc_create_session(struct nfs_client *clp, struct rpc_cred *cred)
  5262. {
  5263. int status;
  5264. unsigned *ptr;
  5265. struct nfs4_session *session = clp->cl_session;
  5266. dprintk("--> %s clp=%p session=%p\n", __func__, clp, session);
  5267. status = _nfs4_proc_create_session(clp, cred);
  5268. if (status)
  5269. goto out;
  5270. /* Init or reset the session slot tables */
  5271. status = nfs4_setup_session_slot_tables(session);
  5272. dprintk("slot table setup returned %d\n", status);
  5273. if (status)
  5274. goto out;
  5275. ptr = (unsigned *)&session->sess_id.data[0];
  5276. dprintk("%s client>seqid %d sessionid %u:%u:%u:%u\n", __func__,
  5277. clp->cl_seqid, ptr[0], ptr[1], ptr[2], ptr[3]);
  5278. out:
  5279. dprintk("<-- %s\n", __func__);
  5280. return status;
  5281. }
  5282. /*
  5283. * Issue the over-the-wire RPC DESTROY_SESSION.
  5284. * The caller must serialize access to this routine.
  5285. */
  5286. int nfs4_proc_destroy_session(struct nfs4_session *session,
  5287. struct rpc_cred *cred)
  5288. {
  5289. struct rpc_message msg = {
  5290. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_SESSION],
  5291. .rpc_argp = session,
  5292. .rpc_cred = cred,
  5293. };
  5294. int status = 0;
  5295. dprintk("--> nfs4_proc_destroy_session\n");
  5296. /* session is still being setup */
  5297. if (session->clp->cl_cons_state != NFS_CS_READY)
  5298. return status;
  5299. status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
  5300. if (status)
  5301. dprintk("NFS: Got error %d from the server on DESTROY_SESSION. "
  5302. "Session has been destroyed regardless...\n", status);
  5303. dprintk("<-- nfs4_proc_destroy_session\n");
  5304. return status;
  5305. }
  5306. /*
  5307. * Renew the cl_session lease.
  5308. */
  5309. struct nfs4_sequence_data {
  5310. struct nfs_client *clp;
  5311. struct nfs4_sequence_args args;
  5312. struct nfs4_sequence_res res;
  5313. };
  5314. static void nfs41_sequence_release(void *data)
  5315. {
  5316. struct nfs4_sequence_data *calldata = data;
  5317. struct nfs_client *clp = calldata->clp;
  5318. if (atomic_read(&clp->cl_count) > 1)
  5319. nfs4_schedule_state_renewal(clp);
  5320. nfs_put_client(clp);
  5321. kfree(calldata);
  5322. }
  5323. static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp)
  5324. {
  5325. switch(task->tk_status) {
  5326. case -NFS4ERR_DELAY:
  5327. rpc_delay(task, NFS4_POLL_RETRY_MAX);
  5328. return -EAGAIN;
  5329. default:
  5330. nfs4_schedule_lease_recovery(clp);
  5331. }
  5332. return 0;
  5333. }
  5334. static void nfs41_sequence_call_done(struct rpc_task *task, void *data)
  5335. {
  5336. struct nfs4_sequence_data *calldata = data;
  5337. struct nfs_client *clp = calldata->clp;
  5338. if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp))
  5339. return;
  5340. if (task->tk_status < 0) {
  5341. dprintk("%s ERROR %d\n", __func__, task->tk_status);
  5342. if (atomic_read(&clp->cl_count) == 1)
  5343. goto out;
  5344. if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) {
  5345. rpc_restart_call_prepare(task);
  5346. return;
  5347. }
  5348. }
  5349. dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred);
  5350. out:
  5351. dprintk("<-- %s\n", __func__);
  5352. }
  5353. static void nfs41_sequence_prepare(struct rpc_task *task, void *data)
  5354. {
  5355. struct nfs4_sequence_data *calldata = data;
  5356. struct nfs_client *clp = calldata->clp;
  5357. struct nfs4_sequence_args *args;
  5358. struct nfs4_sequence_res *res;
  5359. args = task->tk_msg.rpc_argp;
  5360. res = task->tk_msg.rpc_resp;
  5361. nfs41_setup_sequence(clp->cl_session, args, res, task);
  5362. }
  5363. static const struct rpc_call_ops nfs41_sequence_ops = {
  5364. .rpc_call_done = nfs41_sequence_call_done,
  5365. .rpc_call_prepare = nfs41_sequence_prepare,
  5366. .rpc_release = nfs41_sequence_release,
  5367. };
  5368. static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp,
  5369. struct rpc_cred *cred,
  5370. bool is_privileged)
  5371. {
  5372. struct nfs4_sequence_data *calldata;
  5373. struct rpc_message msg = {
  5374. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE],
  5375. .rpc_cred = cred,
  5376. };
  5377. struct rpc_task_setup task_setup_data = {
  5378. .rpc_client = clp->cl_rpcclient,
  5379. .rpc_message = &msg,
  5380. .callback_ops = &nfs41_sequence_ops,
  5381. .flags = RPC_TASK_ASYNC | RPC_TASK_TIMEOUT,
  5382. };
  5383. if (!atomic_inc_not_zero(&clp->cl_count))
  5384. return ERR_PTR(-EIO);
  5385. calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
  5386. if (calldata == NULL) {
  5387. nfs_put_client(clp);
  5388. return ERR_PTR(-ENOMEM);
  5389. }
  5390. nfs41_init_sequence(&calldata->args, &calldata->res, 0);
  5391. if (is_privileged)
  5392. nfs4_set_sequence_privileged(&calldata->args);
  5393. msg.rpc_argp = &calldata->args;
  5394. msg.rpc_resp = &calldata->res;
  5395. calldata->clp = clp;
  5396. task_setup_data.callback_data = calldata;
  5397. return rpc_run_task(&task_setup_data);
  5398. }
  5399. static int nfs41_proc_async_sequence(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
  5400. {
  5401. struct rpc_task *task;
  5402. int ret = 0;
  5403. if ((renew_flags & NFS4_RENEW_TIMEOUT) == 0)
  5404. return 0;
  5405. task = _nfs41_proc_sequence(clp, cred, false);
  5406. if (IS_ERR(task))
  5407. ret = PTR_ERR(task);
  5408. else
  5409. rpc_put_task_async(task);
  5410. dprintk("<-- %s status=%d\n", __func__, ret);
  5411. return ret;
  5412. }
  5413. static int nfs4_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred)
  5414. {
  5415. struct rpc_task *task;
  5416. int ret;
  5417. task = _nfs41_proc_sequence(clp, cred, true);
  5418. if (IS_ERR(task)) {
  5419. ret = PTR_ERR(task);
  5420. goto out;
  5421. }
  5422. ret = rpc_wait_for_completion_task(task);
  5423. if (!ret) {
  5424. struct nfs4_sequence_res *res = task->tk_msg.rpc_resp;
  5425. if (task->tk_status == 0)
  5426. nfs41_handle_sequence_flag_errors(clp, res->sr_status_flags);
  5427. ret = task->tk_status;
  5428. }
  5429. rpc_put_task(task);
  5430. out:
  5431. dprintk("<-- %s status=%d\n", __func__, ret);
  5432. return ret;
  5433. }
  5434. struct nfs4_reclaim_complete_data {
  5435. struct nfs_client *clp;
  5436. struct nfs41_reclaim_complete_args arg;
  5437. struct nfs41_reclaim_complete_res res;
  5438. };
  5439. static void nfs4_reclaim_complete_prepare(struct rpc_task *task, void *data)
  5440. {
  5441. struct nfs4_reclaim_complete_data *calldata = data;
  5442. nfs41_setup_sequence(calldata->clp->cl_session,
  5443. &calldata->arg.seq_args,
  5444. &calldata->res.seq_res,
  5445. task);
  5446. }
  5447. static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp)
  5448. {
  5449. switch(task->tk_status) {
  5450. case 0:
  5451. case -NFS4ERR_COMPLETE_ALREADY:
  5452. case -NFS4ERR_WRONG_CRED: /* What to do here? */
  5453. break;
  5454. case -NFS4ERR_DELAY:
  5455. rpc_delay(task, NFS4_POLL_RETRY_MAX);
  5456. /* fall through */
  5457. case -NFS4ERR_RETRY_UNCACHED_REP:
  5458. return -EAGAIN;
  5459. default:
  5460. nfs4_schedule_lease_recovery(clp);
  5461. }
  5462. return 0;
  5463. }
  5464. static void nfs4_reclaim_complete_done(struct rpc_task *task, void *data)
  5465. {
  5466. struct nfs4_reclaim_complete_data *calldata = data;
  5467. struct nfs_client *clp = calldata->clp;
  5468. struct nfs4_sequence_res *res = &calldata->res.seq_res;
  5469. dprintk("--> %s\n", __func__);
  5470. if (!nfs41_sequence_done(task, res))
  5471. return;
  5472. if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) {
  5473. rpc_restart_call_prepare(task);
  5474. return;
  5475. }
  5476. dprintk("<-- %s\n", __func__);
  5477. }
  5478. static void nfs4_free_reclaim_complete_data(void *data)
  5479. {
  5480. struct nfs4_reclaim_complete_data *calldata = data;
  5481. kfree(calldata);
  5482. }
  5483. static const struct rpc_call_ops nfs4_reclaim_complete_call_ops = {
  5484. .rpc_call_prepare = nfs4_reclaim_complete_prepare,
  5485. .rpc_call_done = nfs4_reclaim_complete_done,
  5486. .rpc_release = nfs4_free_reclaim_complete_data,
  5487. };
  5488. /*
  5489. * Issue a global reclaim complete.
  5490. */
  5491. static int nfs41_proc_reclaim_complete(struct nfs_client *clp)
  5492. {
  5493. struct nfs4_reclaim_complete_data *calldata;
  5494. struct rpc_task *task;
  5495. struct rpc_message msg = {
  5496. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RECLAIM_COMPLETE],
  5497. };
  5498. struct rpc_task_setup task_setup_data = {
  5499. .rpc_client = clp->cl_rpcclient,
  5500. .rpc_message = &msg,
  5501. .callback_ops = &nfs4_reclaim_complete_call_ops,
  5502. .flags = RPC_TASK_ASYNC,
  5503. };
  5504. int status = -ENOMEM;
  5505. dprintk("--> %s\n", __func__);
  5506. calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
  5507. if (calldata == NULL)
  5508. goto out;
  5509. calldata->clp = clp;
  5510. calldata->arg.one_fs = 0;
  5511. nfs41_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 0);
  5512. nfs4_set_sequence_privileged(&calldata->arg.seq_args);
  5513. msg.rpc_argp = &calldata->arg;
  5514. msg.rpc_resp = &calldata->res;
  5515. task_setup_data.callback_data = calldata;
  5516. task = rpc_run_task(&task_setup_data);
  5517. if (IS_ERR(task)) {
  5518. status = PTR_ERR(task);
  5519. goto out;
  5520. }
  5521. status = nfs4_wait_for_completion_rpc_task(task);
  5522. if (status == 0)
  5523. status = task->tk_status;
  5524. rpc_put_task(task);
  5525. return 0;
  5526. out:
  5527. dprintk("<-- %s status=%d\n", __func__, status);
  5528. return status;
  5529. }
  5530. static void
  5531. nfs4_layoutget_prepare(struct rpc_task *task, void *calldata)
  5532. {
  5533. struct nfs4_layoutget *lgp = calldata;
  5534. struct nfs_server *server = NFS_SERVER(lgp->args.inode);
  5535. struct nfs4_session *session = nfs4_get_session(server);
  5536. dprintk("--> %s\n", __func__);
  5537. /* Note the is a race here, where a CB_LAYOUTRECALL can come in
  5538. * right now covering the LAYOUTGET we are about to send.
  5539. * However, that is not so catastrophic, and there seems
  5540. * to be no way to prevent it completely.
  5541. */
  5542. if (nfs41_setup_sequence(session, &lgp->args.seq_args,
  5543. &lgp->res.seq_res, task))
  5544. return;
  5545. if (pnfs_choose_layoutget_stateid(&lgp->args.stateid,
  5546. NFS_I(lgp->args.inode)->layout,
  5547. lgp->args.ctx->state)) {
  5548. rpc_exit(task, NFS4_OK);
  5549. }
  5550. }
  5551. static void nfs4_layoutget_done(struct rpc_task *task, void *calldata)
  5552. {
  5553. struct nfs4_layoutget *lgp = calldata;
  5554. struct inode *inode = lgp->args.inode;
  5555. struct nfs_server *server = NFS_SERVER(inode);
  5556. struct pnfs_layout_hdr *lo;
  5557. struct nfs4_state *state = NULL;
  5558. unsigned long timeo, giveup;
  5559. dprintk("--> %s\n", __func__);
  5560. if (!nfs41_sequence_done(task, &lgp->res.seq_res))
  5561. goto out;
  5562. switch (task->tk_status) {
  5563. case 0:
  5564. goto out;
  5565. case -NFS4ERR_LAYOUTTRYLATER:
  5566. case -NFS4ERR_RECALLCONFLICT:
  5567. timeo = rpc_get_timeout(task->tk_client);
  5568. giveup = lgp->args.timestamp + timeo;
  5569. if (time_after(giveup, jiffies))
  5570. task->tk_status = -NFS4ERR_DELAY;
  5571. break;
  5572. case -NFS4ERR_EXPIRED:
  5573. case -NFS4ERR_BAD_STATEID:
  5574. spin_lock(&inode->i_lock);
  5575. lo = NFS_I(inode)->layout;
  5576. if (!lo || list_empty(&lo->plh_segs)) {
  5577. spin_unlock(&inode->i_lock);
  5578. /* If the open stateid was bad, then recover it. */
  5579. state = lgp->args.ctx->state;
  5580. } else {
  5581. LIST_HEAD(head);
  5582. pnfs_mark_matching_lsegs_invalid(lo, &head, NULL);
  5583. spin_unlock(&inode->i_lock);
  5584. /* Mark the bad layout state as invalid, then
  5585. * retry using the open stateid. */
  5586. pnfs_free_lseg_list(&head);
  5587. }
  5588. }
  5589. if (nfs4_async_handle_error(task, server, state) == -EAGAIN)
  5590. rpc_restart_call_prepare(task);
  5591. out:
  5592. dprintk("<-- %s\n", __func__);
  5593. }
  5594. static size_t max_response_pages(struct nfs_server *server)
  5595. {
  5596. u32 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
  5597. return nfs_page_array_len(0, max_resp_sz);
  5598. }
  5599. static void nfs4_free_pages(struct page **pages, size_t size)
  5600. {
  5601. int i;
  5602. if (!pages)
  5603. return;
  5604. for (i = 0; i < size; i++) {
  5605. if (!pages[i])
  5606. break;
  5607. __free_page(pages[i]);
  5608. }
  5609. kfree(pages);
  5610. }
  5611. static struct page **nfs4_alloc_pages(size_t size, gfp_t gfp_flags)
  5612. {
  5613. struct page **pages;
  5614. int i;
  5615. pages = kcalloc(size, sizeof(struct page *), gfp_flags);
  5616. if (!pages) {
  5617. dprintk("%s: can't alloc array of %zu pages\n", __func__, size);
  5618. return NULL;
  5619. }
  5620. for (i = 0; i < size; i++) {
  5621. pages[i] = alloc_page(gfp_flags);
  5622. if (!pages[i]) {
  5623. dprintk("%s: failed to allocate page\n", __func__);
  5624. nfs4_free_pages(pages, size);
  5625. return NULL;
  5626. }
  5627. }
  5628. return pages;
  5629. }
  5630. static void nfs4_layoutget_release(void *calldata)
  5631. {
  5632. struct nfs4_layoutget *lgp = calldata;
  5633. struct inode *inode = lgp->args.inode;
  5634. struct nfs_server *server = NFS_SERVER(inode);
  5635. size_t max_pages = max_response_pages(server);
  5636. dprintk("--> %s\n", __func__);
  5637. nfs4_free_pages(lgp->args.layout.pages, max_pages);
  5638. pnfs_put_layout_hdr(NFS_I(inode)->layout);
  5639. put_nfs_open_context(lgp->args.ctx);
  5640. kfree(calldata);
  5641. dprintk("<-- %s\n", __func__);
  5642. }
  5643. static const struct rpc_call_ops nfs4_layoutget_call_ops = {
  5644. .rpc_call_prepare = nfs4_layoutget_prepare,
  5645. .rpc_call_done = nfs4_layoutget_done,
  5646. .rpc_release = nfs4_layoutget_release,
  5647. };
  5648. struct pnfs_layout_segment *
  5649. nfs4_proc_layoutget(struct nfs4_layoutget *lgp, gfp_t gfp_flags)
  5650. {
  5651. struct inode *inode = lgp->args.inode;
  5652. struct nfs_server *server = NFS_SERVER(inode);
  5653. size_t max_pages = max_response_pages(server);
  5654. struct rpc_task *task;
  5655. struct rpc_message msg = {
  5656. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTGET],
  5657. .rpc_argp = &lgp->args,
  5658. .rpc_resp = &lgp->res,
  5659. };
  5660. struct rpc_task_setup task_setup_data = {
  5661. .rpc_client = server->client,
  5662. .rpc_message = &msg,
  5663. .callback_ops = &nfs4_layoutget_call_ops,
  5664. .callback_data = lgp,
  5665. .flags = RPC_TASK_ASYNC,
  5666. };
  5667. struct pnfs_layout_segment *lseg = NULL;
  5668. int status = 0;
  5669. dprintk("--> %s\n", __func__);
  5670. lgp->args.layout.pages = nfs4_alloc_pages(max_pages, gfp_flags);
  5671. if (!lgp->args.layout.pages) {
  5672. nfs4_layoutget_release(lgp);
  5673. return ERR_PTR(-ENOMEM);
  5674. }
  5675. lgp->args.layout.pglen = max_pages * PAGE_SIZE;
  5676. lgp->args.timestamp = jiffies;
  5677. lgp->res.layoutp = &lgp->args.layout;
  5678. lgp->res.seq_res.sr_slot = NULL;
  5679. nfs41_init_sequence(&lgp->args.seq_args, &lgp->res.seq_res, 0);
  5680. /* nfs4_layoutget_release calls pnfs_put_layout_hdr */
  5681. pnfs_get_layout_hdr(NFS_I(inode)->layout);
  5682. task = rpc_run_task(&task_setup_data);
  5683. if (IS_ERR(task))
  5684. return ERR_CAST(task);
  5685. status = nfs4_wait_for_completion_rpc_task(task);
  5686. if (status == 0)
  5687. status = task->tk_status;
  5688. /* if layoutp->len is 0, nfs4_layoutget_prepare called rpc_exit */
  5689. if (status == 0 && lgp->res.layoutp->len)
  5690. lseg = pnfs_layout_process(lgp);
  5691. rpc_put_task(task);
  5692. dprintk("<-- %s status=%d\n", __func__, status);
  5693. if (status)
  5694. return ERR_PTR(status);
  5695. return lseg;
  5696. }
  5697. static void
  5698. nfs4_layoutreturn_prepare(struct rpc_task *task, void *calldata)
  5699. {
  5700. struct nfs4_layoutreturn *lrp = calldata;
  5701. dprintk("--> %s\n", __func__);
  5702. nfs41_setup_sequence(lrp->clp->cl_session,
  5703. &lrp->args.seq_args,
  5704. &lrp->res.seq_res,
  5705. task);
  5706. }
  5707. static void nfs4_layoutreturn_done(struct rpc_task *task, void *calldata)
  5708. {
  5709. struct nfs4_layoutreturn *lrp = calldata;
  5710. struct nfs_server *server;
  5711. dprintk("--> %s\n", __func__);
  5712. if (!nfs41_sequence_done(task, &lrp->res.seq_res))
  5713. return;
  5714. server = NFS_SERVER(lrp->args.inode);
  5715. if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) {
  5716. rpc_restart_call_prepare(task);
  5717. return;
  5718. }
  5719. dprintk("<-- %s\n", __func__);
  5720. }
  5721. static void nfs4_layoutreturn_release(void *calldata)
  5722. {
  5723. struct nfs4_layoutreturn *lrp = calldata;
  5724. struct pnfs_layout_hdr *lo = lrp->args.layout;
  5725. dprintk("--> %s\n", __func__);
  5726. spin_lock(&lo->plh_inode->i_lock);
  5727. if (lrp->res.lrs_present)
  5728. pnfs_set_layout_stateid(lo, &lrp->res.stateid, true);
  5729. lo->plh_block_lgets--;
  5730. spin_unlock(&lo->plh_inode->i_lock);
  5731. pnfs_put_layout_hdr(lrp->args.layout);
  5732. kfree(calldata);
  5733. dprintk("<-- %s\n", __func__);
  5734. }
  5735. static const struct rpc_call_ops nfs4_layoutreturn_call_ops = {
  5736. .rpc_call_prepare = nfs4_layoutreturn_prepare,
  5737. .rpc_call_done = nfs4_layoutreturn_done,
  5738. .rpc_release = nfs4_layoutreturn_release,
  5739. };
  5740. int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp)
  5741. {
  5742. struct rpc_task *task;
  5743. struct rpc_message msg = {
  5744. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTRETURN],
  5745. .rpc_argp = &lrp->args,
  5746. .rpc_resp = &lrp->res,
  5747. };
  5748. struct rpc_task_setup task_setup_data = {
  5749. .rpc_client = lrp->clp->cl_rpcclient,
  5750. .rpc_message = &msg,
  5751. .callback_ops = &nfs4_layoutreturn_call_ops,
  5752. .callback_data = lrp,
  5753. };
  5754. int status;
  5755. dprintk("--> %s\n", __func__);
  5756. nfs41_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1);
  5757. task = rpc_run_task(&task_setup_data);
  5758. if (IS_ERR(task))
  5759. return PTR_ERR(task);
  5760. status = task->tk_status;
  5761. dprintk("<-- %s status=%d\n", __func__, status);
  5762. rpc_put_task(task);
  5763. return status;
  5764. }
  5765. /*
  5766. * Retrieve the list of Data Server devices from the MDS.
  5767. */
  5768. static int _nfs4_getdevicelist(struct nfs_server *server,
  5769. const struct nfs_fh *fh,
  5770. struct pnfs_devicelist *devlist)
  5771. {
  5772. struct nfs4_getdevicelist_args args = {
  5773. .fh = fh,
  5774. .layoutclass = server->pnfs_curr_ld->id,
  5775. };
  5776. struct nfs4_getdevicelist_res res = {
  5777. .devlist = devlist,
  5778. };
  5779. struct rpc_message msg = {
  5780. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICELIST],
  5781. .rpc_argp = &args,
  5782. .rpc_resp = &res,
  5783. };
  5784. int status;
  5785. dprintk("--> %s\n", __func__);
  5786. status = nfs4_call_sync(server->client, server, &msg, &args.seq_args,
  5787. &res.seq_res, 0);
  5788. dprintk("<-- %s status=%d\n", __func__, status);
  5789. return status;
  5790. }
  5791. int nfs4_proc_getdevicelist(struct nfs_server *server,
  5792. const struct nfs_fh *fh,
  5793. struct pnfs_devicelist *devlist)
  5794. {
  5795. struct nfs4_exception exception = { };
  5796. int err;
  5797. do {
  5798. err = nfs4_handle_exception(server,
  5799. _nfs4_getdevicelist(server, fh, devlist),
  5800. &exception);
  5801. } while (exception.retry);
  5802. dprintk("%s: err=%d, num_devs=%u\n", __func__,
  5803. err, devlist->num_devs);
  5804. return err;
  5805. }
  5806. EXPORT_SYMBOL_GPL(nfs4_proc_getdevicelist);
  5807. static int
  5808. _nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)
  5809. {
  5810. struct nfs4_getdeviceinfo_args args = {
  5811. .pdev = pdev,
  5812. };
  5813. struct nfs4_getdeviceinfo_res res = {
  5814. .pdev = pdev,
  5815. };
  5816. struct rpc_message msg = {
  5817. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICEINFO],
  5818. .rpc_argp = &args,
  5819. .rpc_resp = &res,
  5820. };
  5821. int status;
  5822. dprintk("--> %s\n", __func__);
  5823. status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
  5824. dprintk("<-- %s status=%d\n", __func__, status);
  5825. return status;
  5826. }
  5827. int nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)
  5828. {
  5829. struct nfs4_exception exception = { };
  5830. int err;
  5831. do {
  5832. err = nfs4_handle_exception(server,
  5833. _nfs4_proc_getdeviceinfo(server, pdev),
  5834. &exception);
  5835. } while (exception.retry);
  5836. return err;
  5837. }
  5838. EXPORT_SYMBOL_GPL(nfs4_proc_getdeviceinfo);
  5839. static void nfs4_layoutcommit_prepare(struct rpc_task *task, void *calldata)
  5840. {
  5841. struct nfs4_layoutcommit_data *data = calldata;
  5842. struct nfs_server *server = NFS_SERVER(data->args.inode);
  5843. struct nfs4_session *session = nfs4_get_session(server);
  5844. nfs41_setup_sequence(session,
  5845. &data->args.seq_args,
  5846. &data->res.seq_res,
  5847. task);
  5848. }
  5849. static void
  5850. nfs4_layoutcommit_done(struct rpc_task *task, void *calldata)
  5851. {
  5852. struct nfs4_layoutcommit_data *data = calldata;
  5853. struct nfs_server *server = NFS_SERVER(data->args.inode);
  5854. if (!nfs41_sequence_done(task, &data->res.seq_res))
  5855. return;
  5856. switch (task->tk_status) { /* Just ignore these failures */
  5857. case -NFS4ERR_DELEG_REVOKED: /* layout was recalled */
  5858. case -NFS4ERR_BADIOMODE: /* no IOMODE_RW layout for range */
  5859. case -NFS4ERR_BADLAYOUT: /* no layout */
  5860. case -NFS4ERR_GRACE: /* loca_recalim always false */
  5861. task->tk_status = 0;
  5862. break;
  5863. case 0:
  5864. nfs_post_op_update_inode_force_wcc(data->args.inode,
  5865. data->res.fattr);
  5866. break;
  5867. default:
  5868. if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) {
  5869. rpc_restart_call_prepare(task);
  5870. return;
  5871. }
  5872. }
  5873. }
  5874. static void nfs4_layoutcommit_release(void *calldata)
  5875. {
  5876. struct nfs4_layoutcommit_data *data = calldata;
  5877. pnfs_cleanup_layoutcommit(data);
  5878. put_rpccred(data->cred);
  5879. kfree(data);
  5880. }
  5881. static const struct rpc_call_ops nfs4_layoutcommit_ops = {
  5882. .rpc_call_prepare = nfs4_layoutcommit_prepare,
  5883. .rpc_call_done = nfs4_layoutcommit_done,
  5884. .rpc_release = nfs4_layoutcommit_release,
  5885. };
  5886. int
  5887. nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync)
  5888. {
  5889. struct rpc_message msg = {
  5890. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTCOMMIT],
  5891. .rpc_argp = &data->args,
  5892. .rpc_resp = &data->res,
  5893. .rpc_cred = data->cred,
  5894. };
  5895. struct rpc_task_setup task_setup_data = {
  5896. .task = &data->task,
  5897. .rpc_client = NFS_CLIENT(data->args.inode),
  5898. .rpc_message = &msg,
  5899. .callback_ops = &nfs4_layoutcommit_ops,
  5900. .callback_data = data,
  5901. .flags = RPC_TASK_ASYNC,
  5902. };
  5903. struct rpc_task *task;
  5904. int status = 0;
  5905. dprintk("NFS: %4d initiating layoutcommit call. sync %d "
  5906. "lbw: %llu inode %lu\n",
  5907. data->task.tk_pid, sync,
  5908. data->args.lastbytewritten,
  5909. data->args.inode->i_ino);
  5910. nfs41_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
  5911. task = rpc_run_task(&task_setup_data);
  5912. if (IS_ERR(task))
  5913. return PTR_ERR(task);
  5914. if (sync == false)
  5915. goto out;
  5916. status = nfs4_wait_for_completion_rpc_task(task);
  5917. if (status != 0)
  5918. goto out;
  5919. status = task->tk_status;
  5920. out:
  5921. dprintk("%s: status %d\n", __func__, status);
  5922. rpc_put_task(task);
  5923. return status;
  5924. }
  5925. static int
  5926. _nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
  5927. struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors)
  5928. {
  5929. struct nfs41_secinfo_no_name_args args = {
  5930. .style = SECINFO_STYLE_CURRENT_FH,
  5931. };
  5932. struct nfs4_secinfo_res res = {
  5933. .flavors = flavors,
  5934. };
  5935. struct rpc_message msg = {
  5936. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO_NO_NAME],
  5937. .rpc_argp = &args,
  5938. .rpc_resp = &res,
  5939. };
  5940. return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
  5941. }
  5942. static int
  5943. nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
  5944. struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors)
  5945. {
  5946. struct nfs4_exception exception = { };
  5947. int err;
  5948. do {
  5949. err = _nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);
  5950. switch (err) {
  5951. case 0:
  5952. case -NFS4ERR_WRONGSEC:
  5953. case -NFS4ERR_NOTSUPP:
  5954. goto out;
  5955. default:
  5956. err = nfs4_handle_exception(server, err, &exception);
  5957. }
  5958. } while (exception.retry);
  5959. out:
  5960. return err;
  5961. }
  5962. static int
  5963. nfs41_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
  5964. struct nfs_fsinfo *info)
  5965. {
  5966. int err;
  5967. struct page *page;
  5968. rpc_authflavor_t flavor;
  5969. struct nfs4_secinfo_flavors *flavors;
  5970. page = alloc_page(GFP_KERNEL);
  5971. if (!page) {
  5972. err = -ENOMEM;
  5973. goto out;
  5974. }
  5975. flavors = page_address(page);
  5976. err = nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);
  5977. /*
  5978. * Fall back on "guess and check" method if
  5979. * the server doesn't support SECINFO_NO_NAME
  5980. */
  5981. if (err == -NFS4ERR_WRONGSEC || err == -NFS4ERR_NOTSUPP) {
  5982. err = nfs4_find_root_sec(server, fhandle, info);
  5983. goto out_freepage;
  5984. }
  5985. if (err)
  5986. goto out_freepage;
  5987. flavor = nfs_find_best_sec(flavors);
  5988. if (err == 0)
  5989. err = nfs4_lookup_root_sec(server, fhandle, info, flavor);
  5990. out_freepage:
  5991. put_page(page);
  5992. if (err == -EACCES)
  5993. return -EPERM;
  5994. out:
  5995. return err;
  5996. }
  5997. static int _nfs41_test_stateid(struct nfs_server *server, nfs4_stateid *stateid)
  5998. {
  5999. int status;
  6000. struct nfs41_test_stateid_args args = {
  6001. .stateid = stateid,
  6002. };
  6003. struct nfs41_test_stateid_res res;
  6004. struct rpc_message msg = {
  6005. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_TEST_STATEID],
  6006. .rpc_argp = &args,
  6007. .rpc_resp = &res,
  6008. };
  6009. dprintk("NFS call test_stateid %p\n", stateid);
  6010. nfs41_init_sequence(&args.seq_args, &res.seq_res, 0);
  6011. nfs4_set_sequence_privileged(&args.seq_args);
  6012. status = nfs4_call_sync_sequence(server->client, server, &msg,
  6013. &args.seq_args, &res.seq_res);
  6014. if (status != NFS_OK) {
  6015. dprintk("NFS reply test_stateid: failed, %d\n", status);
  6016. return status;
  6017. }
  6018. dprintk("NFS reply test_stateid: succeeded, %d\n", -res.status);
  6019. return -res.status;
  6020. }
  6021. /**
  6022. * nfs41_test_stateid - perform a TEST_STATEID operation
  6023. *
  6024. * @server: server / transport on which to perform the operation
  6025. * @stateid: state ID to test
  6026. *
  6027. * Returns NFS_OK if the server recognizes that "stateid" is valid.
  6028. * Otherwise a negative NFS4ERR value is returned if the operation
  6029. * failed or the state ID is not currently valid.
  6030. */
  6031. static int nfs41_test_stateid(struct nfs_server *server, nfs4_stateid *stateid)
  6032. {
  6033. struct nfs4_exception exception = { };
  6034. int err;
  6035. do {
  6036. err = _nfs41_test_stateid(server, stateid);
  6037. if (err != -NFS4ERR_DELAY)
  6038. break;
  6039. nfs4_handle_exception(server, err, &exception);
  6040. } while (exception.retry);
  6041. return err;
  6042. }
  6043. static int _nfs4_free_stateid(struct nfs_server *server, nfs4_stateid *stateid)
  6044. {
  6045. struct nfs41_free_stateid_args args = {
  6046. .stateid = stateid,
  6047. };
  6048. struct nfs41_free_stateid_res res;
  6049. struct rpc_message msg = {
  6050. .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FREE_STATEID],
  6051. .rpc_argp = &args,
  6052. .rpc_resp = &res,
  6053. };
  6054. int status;
  6055. dprintk("NFS call free_stateid %p\n", stateid);
  6056. nfs41_init_sequence(&args.seq_args, &res.seq_res, 0);
  6057. nfs4_set_sequence_privileged(&args.seq_args);
  6058. status = nfs4_call_sync_sequence(server->client, server, &msg,
  6059. &args.seq_args, &res.seq_res);
  6060. dprintk("NFS reply free_stateid: %d\n", status);
  6061. return status;
  6062. }
  6063. /**
  6064. * nfs41_free_stateid - perform a FREE_STATEID operation
  6065. *
  6066. * @server: server / transport on which to perform the operation
  6067. * @stateid: state ID to release
  6068. *
  6069. * Returns NFS_OK if the server freed "stateid". Otherwise a
  6070. * negative NFS4ERR value is returned.
  6071. */
  6072. static int nfs41_free_stateid(struct nfs_server *server, nfs4_stateid *stateid)
  6073. {
  6074. struct nfs4_exception exception = { };
  6075. int err;
  6076. do {
  6077. err = _nfs4_free_stateid(server, stateid);
  6078. if (err != -NFS4ERR_DELAY)
  6079. break;
  6080. nfs4_handle_exception(server, err, &exception);
  6081. } while (exception.retry);
  6082. return err;
  6083. }
  6084. static bool nfs41_match_stateid(const nfs4_stateid *s1,
  6085. const nfs4_stateid *s2)
  6086. {
  6087. if (memcmp(s1->other, s2->other, sizeof(s1->other)) != 0)
  6088. return false;
  6089. if (s1->seqid == s2->seqid)
  6090. return true;
  6091. if (s1->seqid == 0 || s2->seqid == 0)
  6092. return true;
  6093. return false;
  6094. }
  6095. #endif /* CONFIG_NFS_V4_1 */
  6096. static bool nfs4_match_stateid(const nfs4_stateid *s1,
  6097. const nfs4_stateid *s2)
  6098. {
  6099. return nfs4_stateid_match(s1, s2);
  6100. }
  6101. static const struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops = {
  6102. .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
  6103. .state_flag_bit = NFS_STATE_RECLAIM_REBOOT,
  6104. .recover_open = nfs4_open_reclaim,
  6105. .recover_lock = nfs4_lock_reclaim,
  6106. .establish_clid = nfs4_init_clientid,
  6107. .get_clid_cred = nfs4_get_setclientid_cred,
  6108. .detect_trunking = nfs40_discover_server_trunking,
  6109. };
  6110. #if defined(CONFIG_NFS_V4_1)
  6111. static const struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops = {
  6112. .owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
  6113. .state_flag_bit = NFS_STATE_RECLAIM_REBOOT,
  6114. .recover_open = nfs4_open_reclaim,
  6115. .recover_lock = nfs4_lock_reclaim,
  6116. .establish_clid = nfs41_init_clientid,
  6117. .get_clid_cred = nfs4_get_exchange_id_cred,
  6118. .reclaim_complete = nfs41_proc_reclaim_complete,
  6119. .detect_trunking = nfs41_discover_server_trunking,
  6120. };
  6121. #endif /* CONFIG_NFS_V4_1 */
  6122. static const struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops = {
  6123. .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
  6124. .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,
  6125. .recover_open = nfs4_open_expired,
  6126. .recover_lock = nfs4_lock_expired,
  6127. .establish_clid = nfs4_init_clientid,
  6128. .get_clid_cred = nfs4_get_setclientid_cred,
  6129. };
  6130. #if defined(CONFIG_NFS_V4_1)
  6131. static const struct nfs4_state_recovery_ops nfs41_nograce_recovery_ops = {
  6132. .owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
  6133. .state_flag_bit = NFS_STATE_RECLAIM_NOGRACE,
  6134. .recover_open = nfs41_open_expired,
  6135. .recover_lock = nfs41_lock_expired,
  6136. .establish_clid = nfs41_init_clientid,
  6137. .get_clid_cred = nfs4_get_exchange_id_cred,
  6138. };
  6139. #endif /* CONFIG_NFS_V4_1 */
  6140. static const struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = {
  6141. .sched_state_renewal = nfs4_proc_async_renew,
  6142. .get_state_renewal_cred_locked = nfs4_get_renew_cred_locked,
  6143. .renew_lease = nfs4_proc_renew,
  6144. };
  6145. #if defined(CONFIG_NFS_V4_1)
  6146. static const struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = {
  6147. .sched_state_renewal = nfs41_proc_async_sequence,
  6148. .get_state_renewal_cred_locked = nfs4_get_machine_cred_locked,
  6149. .renew_lease = nfs4_proc_sequence,
  6150. };
  6151. #endif
  6152. static const struct nfs4_minor_version_ops nfs_v4_0_minor_ops = {
  6153. .minor_version = 0,
  6154. .init_caps = NFS_CAP_READDIRPLUS
  6155. | NFS_CAP_ATOMIC_OPEN
  6156. | NFS_CAP_CHANGE_ATTR
  6157. | NFS_CAP_POSIX_LOCK,
  6158. .call_sync = _nfs4_call_sync,
  6159. .match_stateid = nfs4_match_stateid,
  6160. .find_root_sec = nfs4_find_root_sec,
  6161. .reboot_recovery_ops = &nfs40_reboot_recovery_ops,
  6162. .nograce_recovery_ops = &nfs40_nograce_recovery_ops,
  6163. .state_renewal_ops = &nfs40_state_renewal_ops,
  6164. };
  6165. #if defined(CONFIG_NFS_V4_1)
  6166. static const struct nfs4_minor_version_ops nfs_v4_1_minor_ops = {
  6167. .minor_version = 1,
  6168. .init_caps = NFS_CAP_READDIRPLUS
  6169. | NFS_CAP_ATOMIC_OPEN
  6170. | NFS_CAP_CHANGE_ATTR
  6171. | NFS_CAP_POSIX_LOCK
  6172. | NFS_CAP_STATEID_NFSV41
  6173. | NFS_CAP_ATOMIC_OPEN_V1,
  6174. .call_sync = nfs4_call_sync_sequence,
  6175. .match_stateid = nfs41_match_stateid,
  6176. .find_root_sec = nfs41_find_root_sec,
  6177. .reboot_recovery_ops = &nfs41_reboot_recovery_ops,
  6178. .nograce_recovery_ops = &nfs41_nograce_recovery_ops,
  6179. .state_renewal_ops = &nfs41_state_renewal_ops,
  6180. };
  6181. #endif
  6182. const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = {
  6183. [0] = &nfs_v4_0_minor_ops,
  6184. #if defined(CONFIG_NFS_V4_1)
  6185. [1] = &nfs_v4_1_minor_ops,
  6186. #endif
  6187. };
  6188. const struct inode_operations nfs4_dir_inode_operations = {
  6189. .create = nfs_create,
  6190. .lookup = nfs_lookup,
  6191. .atomic_open = nfs_atomic_open,
  6192. .link = nfs_link,
  6193. .unlink = nfs_unlink,
  6194. .symlink = nfs_symlink,
  6195. .mkdir = nfs_mkdir,
  6196. .rmdir = nfs_rmdir,
  6197. .mknod = nfs_mknod,
  6198. .rename = nfs_rename,
  6199. .permission = nfs_permission,
  6200. .getattr = nfs_getattr,
  6201. .setattr = nfs_setattr,
  6202. .getxattr = generic_getxattr,
  6203. .setxattr = generic_setxattr,
  6204. .listxattr = generic_listxattr,
  6205. .removexattr = generic_removexattr,
  6206. };
  6207. static const struct inode_operations nfs4_file_inode_operations = {
  6208. .permission = nfs_permission,
  6209. .getattr = nfs_getattr,
  6210. .setattr = nfs_setattr,
  6211. .getxattr = generic_getxattr,
  6212. .setxattr = generic_setxattr,
  6213. .listxattr = generic_listxattr,
  6214. .removexattr = generic_removexattr,
  6215. };
  6216. const struct nfs_rpc_ops nfs_v4_clientops = {
  6217. .version = 4, /* protocol version */
  6218. .dentry_ops = &nfs4_dentry_operations,
  6219. .dir_inode_ops = &nfs4_dir_inode_operations,
  6220. .file_inode_ops = &nfs4_file_inode_operations,
  6221. .file_ops = &nfs4_file_operations,
  6222. .getroot = nfs4_proc_get_root,
  6223. .submount = nfs4_submount,
  6224. .try_mount = nfs4_try_mount,
  6225. .getattr = nfs4_proc_getattr,
  6226. .setattr = nfs4_proc_setattr,
  6227. .lookup = nfs4_proc_lookup,
  6228. .access = nfs4_proc_access,
  6229. .readlink = nfs4_proc_readlink,
  6230. .create = nfs4_proc_create,
  6231. .remove = nfs4_proc_remove,
  6232. .unlink_setup = nfs4_proc_unlink_setup,
  6233. .unlink_rpc_prepare = nfs4_proc_unlink_rpc_prepare,
  6234. .unlink_done = nfs4_proc_unlink_done,
  6235. .rename = nfs4_proc_rename,
  6236. .rename_setup = nfs4_proc_rename_setup,
  6237. .rename_rpc_prepare = nfs4_proc_rename_rpc_prepare,
  6238. .rename_done = nfs4_proc_rename_done,
  6239. .link = nfs4_proc_link,
  6240. .symlink = nfs4_proc_symlink,
  6241. .mkdir = nfs4_proc_mkdir,
  6242. .rmdir = nfs4_proc_remove,
  6243. .readdir = nfs4_proc_readdir,
  6244. .mknod = nfs4_proc_mknod,
  6245. .statfs = nfs4_proc_statfs,
  6246. .fsinfo = nfs4_proc_fsinfo,
  6247. .pathconf = nfs4_proc_pathconf,
  6248. .set_capabilities = nfs4_server_capabilities,
  6249. .decode_dirent = nfs4_decode_dirent,
  6250. .read_setup = nfs4_proc_read_setup,
  6251. .read_pageio_init = pnfs_pageio_init_read,
  6252. .read_rpc_prepare = nfs4_proc_read_rpc_prepare,
  6253. .read_done = nfs4_read_done,
  6254. .write_setup = nfs4_proc_write_setup,
  6255. .write_pageio_init = pnfs_pageio_init_write,
  6256. .write_rpc_prepare = nfs4_proc_write_rpc_prepare,
  6257. .write_done = nfs4_write_done,
  6258. .commit_setup = nfs4_proc_commit_setup,
  6259. .commit_rpc_prepare = nfs4_proc_commit_rpc_prepare,
  6260. .commit_done = nfs4_commit_done,
  6261. .lock = nfs4_proc_lock,
  6262. .clear_acl_cache = nfs4_zap_acl_attr,
  6263. .close_context = nfs4_close_context,
  6264. .open_context = nfs4_atomic_open,
  6265. .have_delegation = nfs4_have_delegation,
  6266. .return_delegation = nfs4_inode_return_delegation,
  6267. .alloc_client = nfs4_alloc_client,
  6268. .init_client = nfs4_init_client,
  6269. .free_client = nfs4_free_client,
  6270. .create_server = nfs4_create_server,
  6271. .clone_server = nfs_clone_server,
  6272. };
  6273. static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = {
  6274. .prefix = XATTR_NAME_NFSV4_ACL,
  6275. .list = nfs4_xattr_list_nfs4_acl,
  6276. .get = nfs4_xattr_get_nfs4_acl,
  6277. .set = nfs4_xattr_set_nfs4_acl,
  6278. };
  6279. const struct xattr_handler *nfs4_xattr_handlers[] = {
  6280. &nfs4_xattr_nfs4_acl_handler,
  6281. NULL
  6282. };
  6283. /*
  6284. * Local variables:
  6285. * c-basic-offset: 8
  6286. * End:
  6287. */