nfs4proc.c 182 KB

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