nfs4proc.c 186 KB

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