nfs4state.c 113 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359
  1. /*
  2. * Copyright (c) 2001 The Regents of the University of Michigan.
  3. * All rights reserved.
  4. *
  5. * Kendrick Smith <kmsmith@umich.edu>
  6. * Andy Adamson <kandros@umich.edu>
  7. *
  8. * Redistribution and use in source and binary forms, with or without
  9. * modification, are permitted provided that the following conditions
  10. * are met:
  11. *
  12. * 1. Redistributions of source code must retain the above copyright
  13. * notice, this list of conditions and the following disclaimer.
  14. * 2. Redistributions in binary form must reproduce the above copyright
  15. * notice, this list of conditions and the following disclaimer in the
  16. * documentation and/or other materials provided with the distribution.
  17. * 3. Neither the name of the University nor the names of its
  18. * contributors may be used to endorse or promote products derived
  19. * from this software without specific prior written permission.
  20. *
  21. * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  22. * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  23. * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  24. * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  26. * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27. * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  28. * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  29. * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  30. * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  31. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32. *
  33. */
  34. #include <linux/file.h>
  35. #include <linux/smp_lock.h>
  36. #include <linux/slab.h>
  37. #include <linux/namei.h>
  38. #include <linux/swap.h>
  39. #include <linux/sunrpc/svcauth_gss.h>
  40. #include <linux/sunrpc/clnt.h>
  41. #include "xdr4.h"
  42. #include "vfs.h"
  43. #define NFSDDBG_FACILITY NFSDDBG_PROC
  44. /* Globals */
  45. time_t nfsd4_lease = 90; /* default lease time */
  46. time_t nfsd4_grace = 90;
  47. static time_t boot_time;
  48. static u32 current_ownerid = 1;
  49. static u32 current_fileid = 1;
  50. static u32 current_delegid = 1;
  51. static stateid_t zerostateid; /* bits all 0 */
  52. static stateid_t onestateid; /* bits all 1 */
  53. static u64 current_sessionid = 1;
  54. #define ZERO_STATEID(stateid) (!memcmp((stateid), &zerostateid, sizeof(stateid_t)))
  55. #define ONE_STATEID(stateid) (!memcmp((stateid), &onestateid, sizeof(stateid_t)))
  56. /* forward declarations */
  57. static struct nfs4_stateid * find_stateid(stateid_t *stid, int flags);
  58. static struct nfs4_delegation * find_delegation_stateid(struct inode *ino, stateid_t *stid);
  59. static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery";
  60. static void nfs4_set_recdir(char *recdir);
  61. /* Locking: */
  62. /* Currently used for almost all code touching nfsv4 state: */
  63. static DEFINE_MUTEX(client_mutex);
  64. /*
  65. * Currently used for the del_recall_lru and file hash table. In an
  66. * effort to decrease the scope of the client_mutex, this spinlock may
  67. * eventually cover more:
  68. */
  69. static DEFINE_SPINLOCK(recall_lock);
  70. static struct kmem_cache *stateowner_slab = NULL;
  71. static struct kmem_cache *file_slab = NULL;
  72. static struct kmem_cache *stateid_slab = NULL;
  73. static struct kmem_cache *deleg_slab = NULL;
  74. void
  75. nfs4_lock_state(void)
  76. {
  77. mutex_lock(&client_mutex);
  78. }
  79. void
  80. nfs4_unlock_state(void)
  81. {
  82. mutex_unlock(&client_mutex);
  83. }
  84. static inline u32
  85. opaque_hashval(const void *ptr, int nbytes)
  86. {
  87. unsigned char *cptr = (unsigned char *) ptr;
  88. u32 x = 0;
  89. while (nbytes--) {
  90. x *= 37;
  91. x += *cptr++;
  92. }
  93. return x;
  94. }
  95. static struct list_head del_recall_lru;
  96. static inline void
  97. put_nfs4_file(struct nfs4_file *fi)
  98. {
  99. if (atomic_dec_and_lock(&fi->fi_ref, &recall_lock)) {
  100. list_del(&fi->fi_hash);
  101. spin_unlock(&recall_lock);
  102. iput(fi->fi_inode);
  103. kmem_cache_free(file_slab, fi);
  104. }
  105. }
  106. static inline void
  107. get_nfs4_file(struct nfs4_file *fi)
  108. {
  109. atomic_inc(&fi->fi_ref);
  110. }
  111. static int num_delegations;
  112. unsigned int max_delegations;
  113. /*
  114. * Open owner state (share locks)
  115. */
  116. /* hash tables for nfs4_stateowner */
  117. #define OWNER_HASH_BITS 8
  118. #define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)
  119. #define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)
  120. #define ownerid_hashval(id) \
  121. ((id) & OWNER_HASH_MASK)
  122. #define ownerstr_hashval(clientid, ownername) \
  123. (((clientid) + opaque_hashval((ownername.data), (ownername.len))) & OWNER_HASH_MASK)
  124. static struct list_head ownerid_hashtbl[OWNER_HASH_SIZE];
  125. static struct list_head ownerstr_hashtbl[OWNER_HASH_SIZE];
  126. /* hash table for nfs4_file */
  127. #define FILE_HASH_BITS 8
  128. #define FILE_HASH_SIZE (1 << FILE_HASH_BITS)
  129. #define FILE_HASH_MASK (FILE_HASH_SIZE - 1)
  130. /* hash table for (open)nfs4_stateid */
  131. #define STATEID_HASH_BITS 10
  132. #define STATEID_HASH_SIZE (1 << STATEID_HASH_BITS)
  133. #define STATEID_HASH_MASK (STATEID_HASH_SIZE - 1)
  134. #define file_hashval(x) \
  135. hash_ptr(x, FILE_HASH_BITS)
  136. #define stateid_hashval(owner_id, file_id) \
  137. (((owner_id) + (file_id)) & STATEID_HASH_MASK)
  138. static struct list_head file_hashtbl[FILE_HASH_SIZE];
  139. static struct list_head stateid_hashtbl[STATEID_HASH_SIZE];
  140. static void __nfs4_file_get_access(struct nfs4_file *fp, int oflag)
  141. {
  142. BUG_ON(!(fp->fi_fds[oflag] || fp->fi_fds[O_RDWR]));
  143. atomic_inc(&fp->fi_access[oflag]);
  144. }
  145. static void nfs4_file_get_access(struct nfs4_file *fp, int oflag)
  146. {
  147. if (oflag == O_RDWR) {
  148. __nfs4_file_get_access(fp, O_RDONLY);
  149. __nfs4_file_get_access(fp, O_WRONLY);
  150. } else
  151. __nfs4_file_get_access(fp, oflag);
  152. }
  153. static void nfs4_file_put_fd(struct nfs4_file *fp, int oflag)
  154. {
  155. if (fp->fi_fds[oflag]) {
  156. fput(fp->fi_fds[oflag]);
  157. fp->fi_fds[oflag] = NULL;
  158. }
  159. }
  160. static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
  161. {
  162. if (atomic_dec_and_test(&fp->fi_access[oflag])) {
  163. nfs4_file_put_fd(fp, O_RDWR);
  164. nfs4_file_put_fd(fp, oflag);
  165. }
  166. }
  167. static void nfs4_file_put_access(struct nfs4_file *fp, int oflag)
  168. {
  169. if (oflag == O_RDWR) {
  170. __nfs4_file_put_access(fp, O_RDONLY);
  171. __nfs4_file_put_access(fp, O_WRONLY);
  172. } else
  173. __nfs4_file_put_access(fp, oflag);
  174. }
  175. static struct nfs4_delegation *
  176. alloc_init_deleg(struct nfs4_client *clp, struct nfs4_stateid *stp, struct svc_fh *current_fh, u32 type)
  177. {
  178. struct nfs4_delegation *dp;
  179. struct nfs4_file *fp = stp->st_file;
  180. dprintk("NFSD alloc_init_deleg\n");
  181. /*
  182. * Major work on the lease subsystem (for example, to support
  183. * calbacks on stat) will be required before we can support
  184. * write delegations properly.
  185. */
  186. if (type != NFS4_OPEN_DELEGATE_READ)
  187. return NULL;
  188. if (fp->fi_had_conflict)
  189. return NULL;
  190. if (num_delegations > max_delegations)
  191. return NULL;
  192. dp = kmem_cache_alloc(deleg_slab, GFP_KERNEL);
  193. if (dp == NULL)
  194. return dp;
  195. num_delegations++;
  196. INIT_LIST_HEAD(&dp->dl_perfile);
  197. INIT_LIST_HEAD(&dp->dl_perclnt);
  198. INIT_LIST_HEAD(&dp->dl_recall_lru);
  199. dp->dl_client = clp;
  200. get_nfs4_file(fp);
  201. dp->dl_file = fp;
  202. nfs4_file_get_access(fp, O_RDONLY);
  203. dp->dl_flock = NULL;
  204. dp->dl_type = type;
  205. dp->dl_stateid.si_boot = boot_time;
  206. dp->dl_stateid.si_stateownerid = current_delegid++;
  207. dp->dl_stateid.si_fileid = 0;
  208. dp->dl_stateid.si_generation = 0;
  209. fh_copy_shallow(&dp->dl_fh, &current_fh->fh_handle);
  210. dp->dl_time = 0;
  211. atomic_set(&dp->dl_count, 1);
  212. list_add(&dp->dl_perfile, &fp->fi_delegations);
  213. list_add(&dp->dl_perclnt, &clp->cl_delegations);
  214. INIT_WORK(&dp->dl_recall.cb_work, nfsd4_do_callback_rpc);
  215. return dp;
  216. }
  217. void
  218. nfs4_put_delegation(struct nfs4_delegation *dp)
  219. {
  220. if (atomic_dec_and_test(&dp->dl_count)) {
  221. dprintk("NFSD: freeing dp %p\n",dp);
  222. put_nfs4_file(dp->dl_file);
  223. kmem_cache_free(deleg_slab, dp);
  224. num_delegations--;
  225. }
  226. }
  227. /* Remove the associated file_lock first, then remove the delegation.
  228. * lease_modify() is called to remove the FS_LEASE file_lock from
  229. * the i_flock list, eventually calling nfsd's lock_manager
  230. * fl_release_callback.
  231. */
  232. static void
  233. nfs4_close_delegation(struct nfs4_delegation *dp)
  234. {
  235. struct file *filp = find_readable_file(dp->dl_file);
  236. dprintk("NFSD: close_delegation dp %p\n",dp);
  237. if (dp->dl_flock)
  238. vfs_setlease(filp, F_UNLCK, &dp->dl_flock);
  239. nfs4_file_put_access(dp->dl_file, O_RDONLY);
  240. }
  241. /* Called under the state lock. */
  242. static void
  243. unhash_delegation(struct nfs4_delegation *dp)
  244. {
  245. list_del_init(&dp->dl_perfile);
  246. list_del_init(&dp->dl_perclnt);
  247. spin_lock(&recall_lock);
  248. list_del_init(&dp->dl_recall_lru);
  249. spin_unlock(&recall_lock);
  250. nfs4_close_delegation(dp);
  251. nfs4_put_delegation(dp);
  252. }
  253. /*
  254. * SETCLIENTID state
  255. */
  256. /* client_lock protects the client lru list and session hash table */
  257. static DEFINE_SPINLOCK(client_lock);
  258. /* Hash tables for nfs4_clientid state */
  259. #define CLIENT_HASH_BITS 4
  260. #define CLIENT_HASH_SIZE (1 << CLIENT_HASH_BITS)
  261. #define CLIENT_HASH_MASK (CLIENT_HASH_SIZE - 1)
  262. #define clientid_hashval(id) \
  263. ((id) & CLIENT_HASH_MASK)
  264. #define clientstr_hashval(name) \
  265. (opaque_hashval((name), 8) & CLIENT_HASH_MASK)
  266. /*
  267. * reclaim_str_hashtbl[] holds known client info from previous reset/reboot
  268. * used in reboot/reset lease grace period processing
  269. *
  270. * conf_id_hashtbl[], and conf_str_hashtbl[] hold confirmed
  271. * setclientid_confirmed info.
  272. *
  273. * unconf_str_hastbl[] and unconf_id_hashtbl[] hold unconfirmed
  274. * setclientid info.
  275. *
  276. * client_lru holds client queue ordered by nfs4_client.cl_time
  277. * for lease renewal.
  278. *
  279. * close_lru holds (open) stateowner queue ordered by nfs4_stateowner.so_time
  280. * for last close replay.
  281. */
  282. static struct list_head reclaim_str_hashtbl[CLIENT_HASH_SIZE];
  283. static int reclaim_str_hashtbl_size = 0;
  284. static struct list_head conf_id_hashtbl[CLIENT_HASH_SIZE];
  285. static struct list_head conf_str_hashtbl[CLIENT_HASH_SIZE];
  286. static struct list_head unconf_str_hashtbl[CLIENT_HASH_SIZE];
  287. static struct list_head unconf_id_hashtbl[CLIENT_HASH_SIZE];
  288. static struct list_head client_lru;
  289. static struct list_head close_lru;
  290. static void unhash_generic_stateid(struct nfs4_stateid *stp)
  291. {
  292. list_del(&stp->st_hash);
  293. list_del(&stp->st_perfile);
  294. list_del(&stp->st_perstateowner);
  295. }
  296. static void free_generic_stateid(struct nfs4_stateid *stp)
  297. {
  298. put_nfs4_file(stp->st_file);
  299. kmem_cache_free(stateid_slab, stp);
  300. }
  301. static void release_lock_stateid(struct nfs4_stateid *stp)
  302. {
  303. struct file *file;
  304. unhash_generic_stateid(stp);
  305. file = find_any_file(stp->st_file);
  306. if (file)
  307. locks_remove_posix(file, (fl_owner_t)stp->st_stateowner);
  308. free_generic_stateid(stp);
  309. }
  310. static void unhash_lockowner(struct nfs4_stateowner *sop)
  311. {
  312. struct nfs4_stateid *stp;
  313. list_del(&sop->so_idhash);
  314. list_del(&sop->so_strhash);
  315. list_del(&sop->so_perstateid);
  316. while (!list_empty(&sop->so_stateids)) {
  317. stp = list_first_entry(&sop->so_stateids,
  318. struct nfs4_stateid, st_perstateowner);
  319. release_lock_stateid(stp);
  320. }
  321. }
  322. static void release_lockowner(struct nfs4_stateowner *sop)
  323. {
  324. unhash_lockowner(sop);
  325. nfs4_put_stateowner(sop);
  326. }
  327. static void
  328. release_stateid_lockowners(struct nfs4_stateid *open_stp)
  329. {
  330. struct nfs4_stateowner *lock_sop;
  331. while (!list_empty(&open_stp->st_lockowners)) {
  332. lock_sop = list_entry(open_stp->st_lockowners.next,
  333. struct nfs4_stateowner, so_perstateid);
  334. /* list_del(&open_stp->st_lockowners); */
  335. BUG_ON(lock_sop->so_is_open_owner);
  336. release_lockowner(lock_sop);
  337. }
  338. }
  339. /*
  340. * We store the NONE, READ, WRITE, and BOTH bits separately in the
  341. * st_{access,deny}_bmap field of the stateid, in order to track not
  342. * only what share bits are currently in force, but also what
  343. * combinations of share bits previous opens have used. This allows us
  344. * to enforce the recommendation of rfc 3530 14.2.19 that the server
  345. * return an error if the client attempt to downgrade to a combination
  346. * of share bits not explicable by closing some of its previous opens.
  347. *
  348. * XXX: This enforcement is actually incomplete, since we don't keep
  349. * track of access/deny bit combinations; so, e.g., we allow:
  350. *
  351. * OPEN allow read, deny write
  352. * OPEN allow both, deny none
  353. * DOWNGRADE allow read, deny none
  354. *
  355. * which we should reject.
  356. */
  357. static void
  358. set_access(unsigned int *access, unsigned long bmap) {
  359. int i;
  360. *access = 0;
  361. for (i = 1; i < 4; i++) {
  362. if (test_bit(i, &bmap))
  363. *access |= i;
  364. }
  365. }
  366. static void
  367. set_deny(unsigned int *deny, unsigned long bmap) {
  368. int i;
  369. *deny = 0;
  370. for (i = 0; i < 4; i++) {
  371. if (test_bit(i, &bmap))
  372. *deny |= i ;
  373. }
  374. }
  375. static int
  376. test_share(struct nfs4_stateid *stp, struct nfsd4_open *open) {
  377. unsigned int access, deny;
  378. set_access(&access, stp->st_access_bmap);
  379. set_deny(&deny, stp->st_deny_bmap);
  380. if ((access & open->op_share_deny) || (deny & open->op_share_access))
  381. return 0;
  382. return 1;
  383. }
  384. static int nfs4_access_to_omode(u32 access)
  385. {
  386. switch (access & NFS4_SHARE_ACCESS_BOTH) {
  387. case NFS4_SHARE_ACCESS_READ:
  388. return O_RDONLY;
  389. case NFS4_SHARE_ACCESS_WRITE:
  390. return O_WRONLY;
  391. case NFS4_SHARE_ACCESS_BOTH:
  392. return O_RDWR;
  393. }
  394. BUG();
  395. }
  396. static int nfs4_access_bmap_to_omode(struct nfs4_stateid *stp)
  397. {
  398. unsigned int access;
  399. set_access(&access, stp->st_access_bmap);
  400. return nfs4_access_to_omode(access);
  401. }
  402. static void release_open_stateid(struct nfs4_stateid *stp)
  403. {
  404. int oflag = nfs4_access_bmap_to_omode(stp);
  405. unhash_generic_stateid(stp);
  406. release_stateid_lockowners(stp);
  407. nfs4_file_put_access(stp->st_file, oflag);
  408. free_generic_stateid(stp);
  409. }
  410. static void unhash_openowner(struct nfs4_stateowner *sop)
  411. {
  412. struct nfs4_stateid *stp;
  413. list_del(&sop->so_idhash);
  414. list_del(&sop->so_strhash);
  415. list_del(&sop->so_perclient);
  416. list_del(&sop->so_perstateid); /* XXX: necessary? */
  417. while (!list_empty(&sop->so_stateids)) {
  418. stp = list_first_entry(&sop->so_stateids,
  419. struct nfs4_stateid, st_perstateowner);
  420. release_open_stateid(stp);
  421. }
  422. }
  423. static void release_openowner(struct nfs4_stateowner *sop)
  424. {
  425. unhash_openowner(sop);
  426. list_del(&sop->so_close_lru);
  427. nfs4_put_stateowner(sop);
  428. }
  429. #define SESSION_HASH_SIZE 512
  430. static struct list_head sessionid_hashtbl[SESSION_HASH_SIZE];
  431. static inline int
  432. hash_sessionid(struct nfs4_sessionid *sessionid)
  433. {
  434. struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
  435. return sid->sequence % SESSION_HASH_SIZE;
  436. }
  437. static inline void
  438. dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
  439. {
  440. u32 *ptr = (u32 *)(&sessionid->data[0]);
  441. dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
  442. }
  443. static void
  444. gen_sessionid(struct nfsd4_session *ses)
  445. {
  446. struct nfs4_client *clp = ses->se_client;
  447. struct nfsd4_sessionid *sid;
  448. sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
  449. sid->clientid = clp->cl_clientid;
  450. sid->sequence = current_sessionid++;
  451. sid->reserved = 0;
  452. }
  453. /*
  454. * The protocol defines ca_maxresponssize_cached to include the size of
  455. * the rpc header, but all we need to cache is the data starting after
  456. * the end of the initial SEQUENCE operation--the rest we regenerate
  457. * each time. Therefore we can advertise a ca_maxresponssize_cached
  458. * value that is the number of bytes in our cache plus a few additional
  459. * bytes. In order to stay on the safe side, and not promise more than
  460. * we can cache, those additional bytes must be the minimum possible: 24
  461. * bytes of rpc header (xid through accept state, with AUTH_NULL
  462. * verifier), 12 for the compound header (with zero-length tag), and 44
  463. * for the SEQUENCE op response:
  464. */
  465. #define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44)
  466. static void
  467. free_session_slots(struct nfsd4_session *ses)
  468. {
  469. int i;
  470. for (i = 0; i < ses->se_fchannel.maxreqs; i++)
  471. kfree(ses->se_slots[i]);
  472. }
  473. /*
  474. * We don't actually need to cache the rpc and session headers, so we
  475. * can allocate a little less for each slot:
  476. */
  477. static inline int slot_bytes(struct nfsd4_channel_attrs *ca)
  478. {
  479. return ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
  480. }
  481. static int nfsd4_sanitize_slot_size(u32 size)
  482. {
  483. size -= NFSD_MIN_HDR_SEQ_SZ; /* We don't cache the rpc header */
  484. size = min_t(u32, size, NFSD_SLOT_CACHE_SIZE);
  485. return size;
  486. }
  487. /*
  488. * XXX: If we run out of reserved DRC memory we could (up to a point)
  489. * re-negotiate active sessions and reduce their slot usage to make
  490. * rooom for new connections. For now we just fail the create session.
  491. */
  492. static int nfsd4_get_drc_mem(int slotsize, u32 num)
  493. {
  494. int avail;
  495. num = min_t(u32, num, NFSD_MAX_SLOTS_PER_SESSION);
  496. spin_lock(&nfsd_drc_lock);
  497. avail = min_t(int, NFSD_MAX_MEM_PER_SESSION,
  498. nfsd_drc_max_mem - nfsd_drc_mem_used);
  499. num = min_t(int, num, avail / slotsize);
  500. nfsd_drc_mem_used += num * slotsize;
  501. spin_unlock(&nfsd_drc_lock);
  502. return num;
  503. }
  504. static void nfsd4_put_drc_mem(int slotsize, int num)
  505. {
  506. spin_lock(&nfsd_drc_lock);
  507. nfsd_drc_mem_used -= slotsize * num;
  508. spin_unlock(&nfsd_drc_lock);
  509. }
  510. static struct nfsd4_session *alloc_session(int slotsize, int numslots)
  511. {
  512. struct nfsd4_session *new;
  513. int mem, i;
  514. BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
  515. + sizeof(struct nfsd4_session) > PAGE_SIZE);
  516. mem = numslots * sizeof(struct nfsd4_slot *);
  517. new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
  518. if (!new)
  519. return NULL;
  520. /* allocate each struct nfsd4_slot and data cache in one piece */
  521. for (i = 0; i < numslots; i++) {
  522. mem = sizeof(struct nfsd4_slot) + slotsize;
  523. new->se_slots[i] = kzalloc(mem, GFP_KERNEL);
  524. if (!new->se_slots[i])
  525. goto out_free;
  526. }
  527. return new;
  528. out_free:
  529. while (i--)
  530. kfree(new->se_slots[i]);
  531. kfree(new);
  532. return NULL;
  533. }
  534. static void init_forechannel_attrs(struct nfsd4_channel_attrs *new, struct nfsd4_channel_attrs *req, int numslots, int slotsize)
  535. {
  536. u32 maxrpc = nfsd_serv->sv_max_mesg;
  537. new->maxreqs = numslots;
  538. new->maxresp_cached = slotsize + NFSD_MIN_HDR_SEQ_SZ;
  539. new->maxreq_sz = min_t(u32, req->maxreq_sz, maxrpc);
  540. new->maxresp_sz = min_t(u32, req->maxresp_sz, maxrpc);
  541. new->maxops = min_t(u32, req->maxops, NFSD_MAX_OPS_PER_COMPOUND);
  542. }
  543. static void free_conn(struct nfsd4_conn *c)
  544. {
  545. svc_xprt_put(c->cn_xprt);
  546. kfree(c);
  547. }
  548. static void nfsd4_conn_lost(struct svc_xpt_user *u)
  549. {
  550. struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
  551. struct nfs4_client *clp = c->cn_session->se_client;
  552. spin_lock(&clp->cl_lock);
  553. if (!list_empty(&c->cn_persession)) {
  554. list_del(&c->cn_persession);
  555. free_conn(c);
  556. }
  557. spin_unlock(&clp->cl_lock);
  558. }
  559. static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp)
  560. {
  561. struct nfsd4_conn *conn;
  562. conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
  563. if (!conn)
  564. return NULL;
  565. svc_xprt_get(rqstp->rq_xprt);
  566. conn->cn_xprt = rqstp->rq_xprt;
  567. conn->cn_flags = NFS4_CDFC4_FORE;
  568. INIT_LIST_HEAD(&conn->cn_xpt_user.list);
  569. return conn;
  570. }
  571. static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
  572. {
  573. conn->cn_session = ses;
  574. list_add(&conn->cn_persession, &ses->se_conns);
  575. }
  576. static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
  577. {
  578. struct nfs4_client *clp = ses->se_client;
  579. spin_lock(&clp->cl_lock);
  580. __nfsd4_hash_conn(conn, ses);
  581. spin_unlock(&clp->cl_lock);
  582. }
  583. static void nfsd4_register_conn(struct nfsd4_conn *conn)
  584. {
  585. conn->cn_xpt_user.callback = nfsd4_conn_lost;
  586. register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
  587. }
  588. static __be32 nfsd4_new_conn(struct svc_rqst *rqstp, struct nfsd4_session *ses)
  589. {
  590. struct nfsd4_conn *conn;
  591. conn = alloc_conn(rqstp);
  592. if (!conn)
  593. return nfserr_jukebox;
  594. nfsd4_hash_conn(conn, ses);
  595. nfsd4_register_conn(conn);
  596. return nfs_ok;
  597. }
  598. static void nfsd4_del_conns(struct nfsd4_session *s)
  599. {
  600. struct nfs4_client *clp = s->se_client;
  601. struct nfsd4_conn *c;
  602. spin_lock(&clp->cl_lock);
  603. while (!list_empty(&s->se_conns)) {
  604. c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
  605. list_del_init(&c->cn_persession);
  606. spin_unlock(&clp->cl_lock);
  607. unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
  608. free_conn(c);
  609. spin_lock(&clp->cl_lock);
  610. }
  611. spin_unlock(&clp->cl_lock);
  612. }
  613. void free_session(struct kref *kref)
  614. {
  615. struct nfsd4_session *ses;
  616. int mem;
  617. ses = container_of(kref, struct nfsd4_session, se_ref);
  618. nfsd4_del_conns(ses);
  619. spin_lock(&nfsd_drc_lock);
  620. mem = ses->se_fchannel.maxreqs * slot_bytes(&ses->se_fchannel);
  621. nfsd_drc_mem_used -= mem;
  622. spin_unlock(&nfsd_drc_lock);
  623. free_session_slots(ses);
  624. kfree(ses);
  625. }
  626. static __be32 alloc_init_session(struct svc_rqst *rqstp, struct nfs4_client *clp, struct nfsd4_create_session *cses)
  627. {
  628. struct nfsd4_session *new;
  629. struct nfsd4_channel_attrs *fchan = &cses->fore_channel;
  630. int numslots, slotsize;
  631. int status;
  632. int idx;
  633. /*
  634. * Note decreasing slot size below client's request may
  635. * make it difficult for client to function correctly, whereas
  636. * decreasing the number of slots will (just?) affect
  637. * performance. When short on memory we therefore prefer to
  638. * decrease number of slots instead of their size.
  639. */
  640. slotsize = nfsd4_sanitize_slot_size(fchan->maxresp_cached);
  641. numslots = nfsd4_get_drc_mem(slotsize, fchan->maxreqs);
  642. new = alloc_session(slotsize, numslots);
  643. if (!new) {
  644. nfsd4_put_drc_mem(slotsize, fchan->maxreqs);
  645. return nfserr_jukebox;
  646. }
  647. init_forechannel_attrs(&new->se_fchannel, fchan, numslots, slotsize);
  648. new->se_client = clp;
  649. gen_sessionid(new);
  650. memcpy(clp->cl_sessionid.data, new->se_sessionid.data,
  651. NFS4_MAX_SESSIONID_LEN);
  652. INIT_LIST_HEAD(&new->se_conns);
  653. new->se_flags = cses->flags;
  654. kref_init(&new->se_ref);
  655. idx = hash_sessionid(&new->se_sessionid);
  656. spin_lock(&client_lock);
  657. list_add(&new->se_hash, &sessionid_hashtbl[idx]);
  658. list_add(&new->se_perclnt, &clp->cl_sessions);
  659. spin_unlock(&client_lock);
  660. status = nfsd4_new_conn(rqstp, new);
  661. if (status) {
  662. free_session(&new->se_ref);
  663. return nfserr_jukebox;
  664. }
  665. return nfs_ok;
  666. }
  667. /* caller must hold client_lock */
  668. static struct nfsd4_session *
  669. find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid)
  670. {
  671. struct nfsd4_session *elem;
  672. int idx;
  673. dump_sessionid(__func__, sessionid);
  674. idx = hash_sessionid(sessionid);
  675. /* Search in the appropriate list */
  676. list_for_each_entry(elem, &sessionid_hashtbl[idx], se_hash) {
  677. if (!memcmp(elem->se_sessionid.data, sessionid->data,
  678. NFS4_MAX_SESSIONID_LEN)) {
  679. return elem;
  680. }
  681. }
  682. dprintk("%s: session not found\n", __func__);
  683. return NULL;
  684. }
  685. /* caller must hold client_lock */
  686. static void
  687. unhash_session(struct nfsd4_session *ses)
  688. {
  689. list_del(&ses->se_hash);
  690. list_del(&ses->se_perclnt);
  691. }
  692. /* must be called under the client_lock */
  693. static inline void
  694. renew_client_locked(struct nfs4_client *clp)
  695. {
  696. if (is_client_expired(clp)) {
  697. dprintk("%s: client (clientid %08x/%08x) already expired\n",
  698. __func__,
  699. clp->cl_clientid.cl_boot,
  700. clp->cl_clientid.cl_id);
  701. return;
  702. }
  703. /*
  704. * Move client to the end to the LRU list.
  705. */
  706. dprintk("renewing client (clientid %08x/%08x)\n",
  707. clp->cl_clientid.cl_boot,
  708. clp->cl_clientid.cl_id);
  709. list_move_tail(&clp->cl_lru, &client_lru);
  710. clp->cl_time = get_seconds();
  711. }
  712. static inline void
  713. renew_client(struct nfs4_client *clp)
  714. {
  715. spin_lock(&client_lock);
  716. renew_client_locked(clp);
  717. spin_unlock(&client_lock);
  718. }
  719. /* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
  720. static int
  721. STALE_CLIENTID(clientid_t *clid)
  722. {
  723. if (clid->cl_boot == boot_time)
  724. return 0;
  725. dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
  726. clid->cl_boot, clid->cl_id, boot_time);
  727. return 1;
  728. }
  729. /*
  730. * XXX Should we use a slab cache ?
  731. * This type of memory management is somewhat inefficient, but we use it
  732. * anyway since SETCLIENTID is not a common operation.
  733. */
  734. static struct nfs4_client *alloc_client(struct xdr_netobj name)
  735. {
  736. struct nfs4_client *clp;
  737. clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
  738. if (clp == NULL)
  739. return NULL;
  740. clp->cl_name.data = kmalloc(name.len, GFP_KERNEL);
  741. if (clp->cl_name.data == NULL) {
  742. kfree(clp);
  743. return NULL;
  744. }
  745. memcpy(clp->cl_name.data, name.data, name.len);
  746. clp->cl_name.len = name.len;
  747. return clp;
  748. }
  749. static inline void
  750. free_client(struct nfs4_client *clp)
  751. {
  752. if (clp->cl_cred.cr_group_info)
  753. put_group_info(clp->cl_cred.cr_group_info);
  754. kfree(clp->cl_principal);
  755. kfree(clp->cl_name.data);
  756. kfree(clp);
  757. }
  758. void
  759. release_session_client(struct nfsd4_session *session)
  760. {
  761. struct nfs4_client *clp = session->se_client;
  762. if (!atomic_dec_and_lock(&clp->cl_refcount, &client_lock))
  763. return;
  764. if (is_client_expired(clp)) {
  765. free_client(clp);
  766. session->se_client = NULL;
  767. } else
  768. renew_client_locked(clp);
  769. spin_unlock(&client_lock);
  770. }
  771. /* must be called under the client_lock */
  772. static inline void
  773. unhash_client_locked(struct nfs4_client *clp)
  774. {
  775. mark_client_expired(clp);
  776. list_del(&clp->cl_lru);
  777. while (!list_empty(&clp->cl_sessions)) {
  778. struct nfsd4_session *ses;
  779. ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
  780. se_perclnt);
  781. unhash_session(ses);
  782. nfsd4_put_session(ses);
  783. }
  784. }
  785. static void
  786. expire_client(struct nfs4_client *clp)
  787. {
  788. struct nfs4_stateowner *sop;
  789. struct nfs4_delegation *dp;
  790. struct list_head reaplist;
  791. INIT_LIST_HEAD(&reaplist);
  792. spin_lock(&recall_lock);
  793. while (!list_empty(&clp->cl_delegations)) {
  794. dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
  795. dprintk("NFSD: expire client. dp %p, fp %p\n", dp,
  796. dp->dl_flock);
  797. list_del_init(&dp->dl_perclnt);
  798. list_move(&dp->dl_recall_lru, &reaplist);
  799. }
  800. spin_unlock(&recall_lock);
  801. while (!list_empty(&reaplist)) {
  802. dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
  803. list_del_init(&dp->dl_recall_lru);
  804. unhash_delegation(dp);
  805. }
  806. while (!list_empty(&clp->cl_openowners)) {
  807. sop = list_entry(clp->cl_openowners.next, struct nfs4_stateowner, so_perclient);
  808. release_openowner(sop);
  809. }
  810. nfsd4_shutdown_callback(clp);
  811. if (clp->cl_cb_conn.cb_xprt)
  812. svc_xprt_put(clp->cl_cb_conn.cb_xprt);
  813. list_del(&clp->cl_idhash);
  814. list_del(&clp->cl_strhash);
  815. spin_lock(&client_lock);
  816. unhash_client_locked(clp);
  817. if (atomic_read(&clp->cl_refcount) == 0)
  818. free_client(clp);
  819. spin_unlock(&client_lock);
  820. }
  821. static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
  822. {
  823. memcpy(target->cl_verifier.data, source->data,
  824. sizeof(target->cl_verifier.data));
  825. }
  826. static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
  827. {
  828. target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
  829. target->cl_clientid.cl_id = source->cl_clientid.cl_id;
  830. }
  831. static void copy_cred(struct svc_cred *target, struct svc_cred *source)
  832. {
  833. target->cr_uid = source->cr_uid;
  834. target->cr_gid = source->cr_gid;
  835. target->cr_group_info = source->cr_group_info;
  836. get_group_info(target->cr_group_info);
  837. }
  838. static int same_name(const char *n1, const char *n2)
  839. {
  840. return 0 == memcmp(n1, n2, HEXDIR_LEN);
  841. }
  842. static int
  843. same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
  844. {
  845. return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
  846. }
  847. static int
  848. same_clid(clientid_t *cl1, clientid_t *cl2)
  849. {
  850. return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
  851. }
  852. /* XXX what about NGROUP */
  853. static int
  854. same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
  855. {
  856. return cr1->cr_uid == cr2->cr_uid;
  857. }
  858. static void gen_clid(struct nfs4_client *clp)
  859. {
  860. static u32 current_clientid = 1;
  861. clp->cl_clientid.cl_boot = boot_time;
  862. clp->cl_clientid.cl_id = current_clientid++;
  863. }
  864. static void gen_confirm(struct nfs4_client *clp)
  865. {
  866. static u32 i;
  867. u32 *p;
  868. p = (u32 *)clp->cl_confirm.data;
  869. *p++ = get_seconds();
  870. *p++ = i++;
  871. }
  872. static struct nfs4_client *create_client(struct xdr_netobj name, char *recdir,
  873. struct svc_rqst *rqstp, nfs4_verifier *verf)
  874. {
  875. struct nfs4_client *clp;
  876. struct sockaddr *sa = svc_addr(rqstp);
  877. char *princ;
  878. clp = alloc_client(name);
  879. if (clp == NULL)
  880. return NULL;
  881. princ = svc_gss_principal(rqstp);
  882. if (princ) {
  883. clp->cl_principal = kstrdup(princ, GFP_KERNEL);
  884. if (clp->cl_principal == NULL) {
  885. free_client(clp);
  886. return NULL;
  887. }
  888. }
  889. memcpy(clp->cl_recdir, recdir, HEXDIR_LEN);
  890. atomic_set(&clp->cl_refcount, 0);
  891. atomic_set(&clp->cl_cb_set, 0);
  892. INIT_LIST_HEAD(&clp->cl_idhash);
  893. INIT_LIST_HEAD(&clp->cl_strhash);
  894. INIT_LIST_HEAD(&clp->cl_openowners);
  895. INIT_LIST_HEAD(&clp->cl_delegations);
  896. INIT_LIST_HEAD(&clp->cl_sessions);
  897. INIT_LIST_HEAD(&clp->cl_lru);
  898. spin_lock_init(&clp->cl_lock);
  899. INIT_WORK(&clp->cl_cb_null.cb_work, nfsd4_do_callback_rpc);
  900. clp->cl_time = get_seconds();
  901. clear_bit(0, &clp->cl_cb_slot_busy);
  902. rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
  903. copy_verf(clp, verf);
  904. rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
  905. clp->cl_flavor = rqstp->rq_flavor;
  906. copy_cred(&clp->cl_cred, &rqstp->rq_cred);
  907. gen_confirm(clp);
  908. return clp;
  909. }
  910. static int check_name(struct xdr_netobj name)
  911. {
  912. if (name.len == 0)
  913. return 0;
  914. if (name.len > NFS4_OPAQUE_LIMIT) {
  915. dprintk("NFSD: check_name: name too long(%d)!\n", name.len);
  916. return 0;
  917. }
  918. return 1;
  919. }
  920. static void
  921. add_to_unconfirmed(struct nfs4_client *clp, unsigned int strhashval)
  922. {
  923. unsigned int idhashval;
  924. list_add(&clp->cl_strhash, &unconf_str_hashtbl[strhashval]);
  925. idhashval = clientid_hashval(clp->cl_clientid.cl_id);
  926. list_add(&clp->cl_idhash, &unconf_id_hashtbl[idhashval]);
  927. renew_client(clp);
  928. }
  929. static void
  930. move_to_confirmed(struct nfs4_client *clp)
  931. {
  932. unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
  933. unsigned int strhashval;
  934. dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
  935. list_move(&clp->cl_idhash, &conf_id_hashtbl[idhashval]);
  936. strhashval = clientstr_hashval(clp->cl_recdir);
  937. list_move(&clp->cl_strhash, &conf_str_hashtbl[strhashval]);
  938. renew_client(clp);
  939. }
  940. static struct nfs4_client *
  941. find_confirmed_client(clientid_t *clid)
  942. {
  943. struct nfs4_client *clp;
  944. unsigned int idhashval = clientid_hashval(clid->cl_id);
  945. list_for_each_entry(clp, &conf_id_hashtbl[idhashval], cl_idhash) {
  946. if (same_clid(&clp->cl_clientid, clid))
  947. return clp;
  948. }
  949. return NULL;
  950. }
  951. static struct nfs4_client *
  952. find_unconfirmed_client(clientid_t *clid)
  953. {
  954. struct nfs4_client *clp;
  955. unsigned int idhashval = clientid_hashval(clid->cl_id);
  956. list_for_each_entry(clp, &unconf_id_hashtbl[idhashval], cl_idhash) {
  957. if (same_clid(&clp->cl_clientid, clid))
  958. return clp;
  959. }
  960. return NULL;
  961. }
  962. /*
  963. * Return 1 iff clp's clientid establishment method matches the use_exchange_id
  964. * parameter. Matching is based on the fact the at least one of the
  965. * EXCHGID4_FLAG_USE_{NON_PNFS,PNFS_MDS,PNFS_DS} flags must be set for v4.1
  966. *
  967. * FIXME: we need to unify the clientid namespaces for nfsv4.x
  968. * and correctly deal with client upgrade/downgrade in EXCHANGE_ID
  969. * and SET_CLIENTID{,_CONFIRM}
  970. */
  971. static inline int
  972. match_clientid_establishment(struct nfs4_client *clp, bool use_exchange_id)
  973. {
  974. bool has_exchange_flags = (clp->cl_exchange_flags != 0);
  975. return use_exchange_id == has_exchange_flags;
  976. }
  977. static struct nfs4_client *
  978. find_confirmed_client_by_str(const char *dname, unsigned int hashval,
  979. bool use_exchange_id)
  980. {
  981. struct nfs4_client *clp;
  982. list_for_each_entry(clp, &conf_str_hashtbl[hashval], cl_strhash) {
  983. if (same_name(clp->cl_recdir, dname) &&
  984. match_clientid_establishment(clp, use_exchange_id))
  985. return clp;
  986. }
  987. return NULL;
  988. }
  989. static struct nfs4_client *
  990. find_unconfirmed_client_by_str(const char *dname, unsigned int hashval,
  991. bool use_exchange_id)
  992. {
  993. struct nfs4_client *clp;
  994. list_for_each_entry(clp, &unconf_str_hashtbl[hashval], cl_strhash) {
  995. if (same_name(clp->cl_recdir, dname) &&
  996. match_clientid_establishment(clp, use_exchange_id))
  997. return clp;
  998. }
  999. return NULL;
  1000. }
  1001. static void
  1002. gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, u32 scopeid)
  1003. {
  1004. struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
  1005. unsigned short expected_family;
  1006. /* Currently, we only support tcp and tcp6 for the callback channel */
  1007. if (se->se_callback_netid_len == 3 &&
  1008. !memcmp(se->se_callback_netid_val, "tcp", 3))
  1009. expected_family = AF_INET;
  1010. else if (se->se_callback_netid_len == 4 &&
  1011. !memcmp(se->se_callback_netid_val, "tcp6", 4))
  1012. expected_family = AF_INET6;
  1013. else
  1014. goto out_err;
  1015. conn->cb_addrlen = rpc_uaddr2sockaddr(se->se_callback_addr_val,
  1016. se->se_callback_addr_len,
  1017. (struct sockaddr *)&conn->cb_addr,
  1018. sizeof(conn->cb_addr));
  1019. if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
  1020. goto out_err;
  1021. if (conn->cb_addr.ss_family == AF_INET6)
  1022. ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
  1023. conn->cb_minorversion = 0;
  1024. conn->cb_prog = se->se_callback_prog;
  1025. conn->cb_ident = se->se_callback_ident;
  1026. return;
  1027. out_err:
  1028. conn->cb_addr.ss_family = AF_UNSPEC;
  1029. conn->cb_addrlen = 0;
  1030. dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
  1031. "will not receive delegations\n",
  1032. clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
  1033. return;
  1034. }
  1035. /*
  1036. * Cache a reply. nfsd4_check_drc_limit() has bounded the cache size.
  1037. */
  1038. void
  1039. nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
  1040. {
  1041. struct nfsd4_slot *slot = resp->cstate.slot;
  1042. unsigned int base;
  1043. dprintk("--> %s slot %p\n", __func__, slot);
  1044. slot->sl_opcnt = resp->opcnt;
  1045. slot->sl_status = resp->cstate.status;
  1046. if (nfsd4_not_cached(resp)) {
  1047. slot->sl_datalen = 0;
  1048. return;
  1049. }
  1050. slot->sl_datalen = (char *)resp->p - (char *)resp->cstate.datap;
  1051. base = (char *)resp->cstate.datap -
  1052. (char *)resp->xbuf->head[0].iov_base;
  1053. if (read_bytes_from_xdr_buf(resp->xbuf, base, slot->sl_data,
  1054. slot->sl_datalen))
  1055. WARN("%s: sessions DRC could not cache compound\n", __func__);
  1056. return;
  1057. }
  1058. /*
  1059. * Encode the replay sequence operation from the slot values.
  1060. * If cachethis is FALSE encode the uncached rep error on the next
  1061. * operation which sets resp->p and increments resp->opcnt for
  1062. * nfs4svc_encode_compoundres.
  1063. *
  1064. */
  1065. static __be32
  1066. nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
  1067. struct nfsd4_compoundres *resp)
  1068. {
  1069. struct nfsd4_op *op;
  1070. struct nfsd4_slot *slot = resp->cstate.slot;
  1071. dprintk("--> %s resp->opcnt %d cachethis %u \n", __func__,
  1072. resp->opcnt, resp->cstate.slot->sl_cachethis);
  1073. /* Encode the replayed sequence operation */
  1074. op = &args->ops[resp->opcnt - 1];
  1075. nfsd4_encode_operation(resp, op);
  1076. /* Return nfserr_retry_uncached_rep in next operation. */
  1077. if (args->opcnt > 1 && slot->sl_cachethis == 0) {
  1078. op = &args->ops[resp->opcnt++];
  1079. op->status = nfserr_retry_uncached_rep;
  1080. nfsd4_encode_operation(resp, op);
  1081. }
  1082. return op->status;
  1083. }
  1084. /*
  1085. * The sequence operation is not cached because we can use the slot and
  1086. * session values.
  1087. */
  1088. __be32
  1089. nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
  1090. struct nfsd4_sequence *seq)
  1091. {
  1092. struct nfsd4_slot *slot = resp->cstate.slot;
  1093. __be32 status;
  1094. dprintk("--> %s slot %p\n", __func__, slot);
  1095. /* Either returns 0 or nfserr_retry_uncached */
  1096. status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
  1097. if (status == nfserr_retry_uncached_rep)
  1098. return status;
  1099. /* The sequence operation has been encoded, cstate->datap set. */
  1100. memcpy(resp->cstate.datap, slot->sl_data, slot->sl_datalen);
  1101. resp->opcnt = slot->sl_opcnt;
  1102. resp->p = resp->cstate.datap + XDR_QUADLEN(slot->sl_datalen);
  1103. status = slot->sl_status;
  1104. return status;
  1105. }
  1106. /*
  1107. * Set the exchange_id flags returned by the server.
  1108. */
  1109. static void
  1110. nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
  1111. {
  1112. /* pNFS is not supported */
  1113. new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
  1114. /* Referrals are supported, Migration is not. */
  1115. new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
  1116. /* set the wire flags to return to client. */
  1117. clid->flags = new->cl_exchange_flags;
  1118. }
  1119. __be32
  1120. nfsd4_exchange_id(struct svc_rqst *rqstp,
  1121. struct nfsd4_compound_state *cstate,
  1122. struct nfsd4_exchange_id *exid)
  1123. {
  1124. struct nfs4_client *unconf, *conf, *new;
  1125. int status;
  1126. unsigned int strhashval;
  1127. char dname[HEXDIR_LEN];
  1128. char addr_str[INET6_ADDRSTRLEN];
  1129. nfs4_verifier verf = exid->verifier;
  1130. struct sockaddr *sa = svc_addr(rqstp);
  1131. rpc_ntop(sa, addr_str, sizeof(addr_str));
  1132. dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
  1133. "ip_addr=%s flags %x, spa_how %d\n",
  1134. __func__, rqstp, exid, exid->clname.len, exid->clname.data,
  1135. addr_str, exid->flags, exid->spa_how);
  1136. if (!check_name(exid->clname) || (exid->flags & ~EXCHGID4_FLAG_MASK_A))
  1137. return nfserr_inval;
  1138. /* Currently only support SP4_NONE */
  1139. switch (exid->spa_how) {
  1140. case SP4_NONE:
  1141. break;
  1142. case SP4_SSV:
  1143. return nfserr_encr_alg_unsupp;
  1144. default:
  1145. BUG(); /* checked by xdr code */
  1146. case SP4_MACH_CRED:
  1147. return nfserr_serverfault; /* no excuse :-/ */
  1148. }
  1149. status = nfs4_make_rec_clidname(dname, &exid->clname);
  1150. if (status)
  1151. goto error;
  1152. strhashval = clientstr_hashval(dname);
  1153. nfs4_lock_state();
  1154. status = nfs_ok;
  1155. conf = find_confirmed_client_by_str(dname, strhashval, true);
  1156. if (conf) {
  1157. if (!same_verf(&verf, &conf->cl_verifier)) {
  1158. /* 18.35.4 case 8 */
  1159. if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
  1160. status = nfserr_not_same;
  1161. goto out;
  1162. }
  1163. /* Client reboot: destroy old state */
  1164. expire_client(conf);
  1165. goto out_new;
  1166. }
  1167. if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
  1168. /* 18.35.4 case 9 */
  1169. if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
  1170. status = nfserr_perm;
  1171. goto out;
  1172. }
  1173. expire_client(conf);
  1174. goto out_new;
  1175. }
  1176. /*
  1177. * Set bit when the owner id and verifier map to an already
  1178. * confirmed client id (18.35.3).
  1179. */
  1180. exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
  1181. /*
  1182. * Falling into 18.35.4 case 2, possible router replay.
  1183. * Leave confirmed record intact and return same result.
  1184. */
  1185. copy_verf(conf, &verf);
  1186. new = conf;
  1187. goto out_copy;
  1188. }
  1189. /* 18.35.4 case 7 */
  1190. if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
  1191. status = nfserr_noent;
  1192. goto out;
  1193. }
  1194. unconf = find_unconfirmed_client_by_str(dname, strhashval, true);
  1195. if (unconf) {
  1196. /*
  1197. * Possible retry or client restart. Per 18.35.4 case 4,
  1198. * a new unconfirmed record should be generated regardless
  1199. * of whether any properties have changed.
  1200. */
  1201. expire_client(unconf);
  1202. }
  1203. out_new:
  1204. /* Normal case */
  1205. new = create_client(exid->clname, dname, rqstp, &verf);
  1206. if (new == NULL) {
  1207. status = nfserr_jukebox;
  1208. goto out;
  1209. }
  1210. gen_clid(new);
  1211. add_to_unconfirmed(new, strhashval);
  1212. out_copy:
  1213. exid->clientid.cl_boot = new->cl_clientid.cl_boot;
  1214. exid->clientid.cl_id = new->cl_clientid.cl_id;
  1215. exid->seqid = 1;
  1216. nfsd4_set_ex_flags(new, exid);
  1217. dprintk("nfsd4_exchange_id seqid %d flags %x\n",
  1218. new->cl_cs_slot.sl_seqid, new->cl_exchange_flags);
  1219. status = nfs_ok;
  1220. out:
  1221. nfs4_unlock_state();
  1222. error:
  1223. dprintk("nfsd4_exchange_id returns %d\n", ntohl(status));
  1224. return status;
  1225. }
  1226. static int
  1227. check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
  1228. {
  1229. dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
  1230. slot_seqid);
  1231. /* The slot is in use, and no response has been sent. */
  1232. if (slot_inuse) {
  1233. if (seqid == slot_seqid)
  1234. return nfserr_jukebox;
  1235. else
  1236. return nfserr_seq_misordered;
  1237. }
  1238. /* Normal */
  1239. if (likely(seqid == slot_seqid + 1))
  1240. return nfs_ok;
  1241. /* Replay */
  1242. if (seqid == slot_seqid)
  1243. return nfserr_replay_cache;
  1244. /* Wraparound */
  1245. if (seqid == 1 && (slot_seqid + 1) == 0)
  1246. return nfs_ok;
  1247. /* Misordered replay or misordered new request */
  1248. return nfserr_seq_misordered;
  1249. }
  1250. /*
  1251. * Cache the create session result into the create session single DRC
  1252. * slot cache by saving the xdr structure. sl_seqid has been set.
  1253. * Do this for solo or embedded create session operations.
  1254. */
  1255. static void
  1256. nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
  1257. struct nfsd4_clid_slot *slot, int nfserr)
  1258. {
  1259. slot->sl_status = nfserr;
  1260. memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
  1261. }
  1262. static __be32
  1263. nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
  1264. struct nfsd4_clid_slot *slot)
  1265. {
  1266. memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
  1267. return slot->sl_status;
  1268. }
  1269. __be32
  1270. nfsd4_create_session(struct svc_rqst *rqstp,
  1271. struct nfsd4_compound_state *cstate,
  1272. struct nfsd4_create_session *cr_ses)
  1273. {
  1274. struct sockaddr *sa = svc_addr(rqstp);
  1275. struct nfs4_client *conf, *unconf;
  1276. struct nfsd4_clid_slot *cs_slot = NULL;
  1277. int status = 0;
  1278. nfs4_lock_state();
  1279. unconf = find_unconfirmed_client(&cr_ses->clientid);
  1280. conf = find_confirmed_client(&cr_ses->clientid);
  1281. if (conf) {
  1282. cs_slot = &conf->cl_cs_slot;
  1283. status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
  1284. if (status == nfserr_replay_cache) {
  1285. dprintk("Got a create_session replay! seqid= %d\n",
  1286. cs_slot->sl_seqid);
  1287. /* Return the cached reply status */
  1288. status = nfsd4_replay_create_session(cr_ses, cs_slot);
  1289. goto out;
  1290. } else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
  1291. status = nfserr_seq_misordered;
  1292. dprintk("Sequence misordered!\n");
  1293. dprintk("Expected seqid= %d but got seqid= %d\n",
  1294. cs_slot->sl_seqid, cr_ses->seqid);
  1295. goto out;
  1296. }
  1297. cs_slot->sl_seqid++;
  1298. } else if (unconf) {
  1299. if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
  1300. !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
  1301. status = nfserr_clid_inuse;
  1302. goto out;
  1303. }
  1304. cs_slot = &unconf->cl_cs_slot;
  1305. status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
  1306. if (status) {
  1307. /* an unconfirmed replay returns misordered */
  1308. status = nfserr_seq_misordered;
  1309. goto out_cache;
  1310. }
  1311. cs_slot->sl_seqid++; /* from 0 to 1 */
  1312. move_to_confirmed(unconf);
  1313. if (cr_ses->flags & SESSION4_BACK_CHAN) {
  1314. unconf->cl_cb_conn.cb_xprt = rqstp->rq_xprt;
  1315. svc_xprt_get(rqstp->rq_xprt);
  1316. rpc_copy_addr(
  1317. (struct sockaddr *)&unconf->cl_cb_conn.cb_addr,
  1318. sa);
  1319. unconf->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
  1320. unconf->cl_cb_conn.cb_minorversion =
  1321. cstate->minorversion;
  1322. unconf->cl_cb_conn.cb_prog = cr_ses->callback_prog;
  1323. unconf->cl_cb_seq_nr = 1;
  1324. nfsd4_probe_callback(unconf, &unconf->cl_cb_conn);
  1325. }
  1326. conf = unconf;
  1327. } else {
  1328. status = nfserr_stale_clientid;
  1329. goto out;
  1330. }
  1331. /*
  1332. * We do not support RDMA or persistent sessions
  1333. */
  1334. cr_ses->flags &= ~SESSION4_PERSIST;
  1335. cr_ses->flags &= ~SESSION4_RDMA;
  1336. status = alloc_init_session(rqstp, conf, cr_ses);
  1337. if (status)
  1338. goto out;
  1339. memcpy(cr_ses->sessionid.data, conf->cl_sessionid.data,
  1340. NFS4_MAX_SESSIONID_LEN);
  1341. cr_ses->seqid = cs_slot->sl_seqid;
  1342. out_cache:
  1343. /* cache solo and embedded create sessions under the state lock */
  1344. nfsd4_cache_create_session(cr_ses, cs_slot, status);
  1345. out:
  1346. nfs4_unlock_state();
  1347. dprintk("%s returns %d\n", __func__, ntohl(status));
  1348. return status;
  1349. }
  1350. static bool nfsd4_last_compound_op(struct svc_rqst *rqstp)
  1351. {
  1352. struct nfsd4_compoundres *resp = rqstp->rq_resp;
  1353. struct nfsd4_compoundargs *argp = rqstp->rq_argp;
  1354. return argp->opcnt == resp->opcnt;
  1355. }
  1356. static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
  1357. {
  1358. if (!session)
  1359. return 0;
  1360. return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
  1361. }
  1362. __be32
  1363. nfsd4_destroy_session(struct svc_rqst *r,
  1364. struct nfsd4_compound_state *cstate,
  1365. struct nfsd4_destroy_session *sessionid)
  1366. {
  1367. struct nfsd4_session *ses;
  1368. u32 status = nfserr_badsession;
  1369. /* Notes:
  1370. * - The confirmed nfs4_client->cl_sessionid holds destroyed sessinid
  1371. * - Should we return nfserr_back_chan_busy if waiting for
  1372. * callbacks on to-be-destroyed session?
  1373. * - Do we need to clear any callback info from previous session?
  1374. */
  1375. if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
  1376. if (!nfsd4_last_compound_op(r))
  1377. return nfserr_not_only_op;
  1378. }
  1379. dump_sessionid(__func__, &sessionid->sessionid);
  1380. spin_lock(&client_lock);
  1381. ses = find_in_sessionid_hashtbl(&sessionid->sessionid);
  1382. if (!ses) {
  1383. spin_unlock(&client_lock);
  1384. goto out;
  1385. }
  1386. unhash_session(ses);
  1387. spin_unlock(&client_lock);
  1388. nfs4_lock_state();
  1389. /* wait for callbacks */
  1390. nfsd4_shutdown_callback(ses->se_client);
  1391. nfs4_unlock_state();
  1392. nfsd4_del_conns(ses);
  1393. nfsd4_put_session(ses);
  1394. status = nfs_ok;
  1395. out:
  1396. dprintk("%s returns %d\n", __func__, ntohl(status));
  1397. return status;
  1398. }
  1399. static struct nfsd4_conn *__nfsd4_find_conn(struct svc_rqst *r, struct nfsd4_session *s)
  1400. {
  1401. struct nfsd4_conn *c;
  1402. list_for_each_entry(c, &s->se_conns, cn_persession) {
  1403. if (c->cn_xprt == r->rq_xprt) {
  1404. return c;
  1405. }
  1406. }
  1407. return NULL;
  1408. }
  1409. static void nfsd4_sequence_check_conn(struct svc_rqst *rqstp, struct nfsd4_session *ses)
  1410. {
  1411. struct nfs4_client *clp = ses->se_client;
  1412. struct nfsd4_conn *c, *new = NULL;
  1413. spin_lock(&clp->cl_lock);
  1414. c = __nfsd4_find_conn(rqstp, ses);
  1415. spin_unlock(&clp->cl_lock);
  1416. if (c)
  1417. return;
  1418. new = alloc_conn(rqstp);
  1419. spin_lock(&clp->cl_lock);
  1420. c = __nfsd4_find_conn(rqstp, ses);
  1421. if (c) {
  1422. spin_unlock(&clp->cl_lock);
  1423. free_conn(new);
  1424. return;
  1425. }
  1426. __nfsd4_hash_conn(new, ses);
  1427. spin_unlock(&clp->cl_lock);
  1428. nfsd4_register_conn(new);
  1429. return;
  1430. }
  1431. __be32
  1432. nfsd4_sequence(struct svc_rqst *rqstp,
  1433. struct nfsd4_compound_state *cstate,
  1434. struct nfsd4_sequence *seq)
  1435. {
  1436. struct nfsd4_compoundres *resp = rqstp->rq_resp;
  1437. struct nfsd4_session *session;
  1438. struct nfsd4_slot *slot;
  1439. int status;
  1440. if (resp->opcnt != 1)
  1441. return nfserr_sequence_pos;
  1442. spin_lock(&client_lock);
  1443. status = nfserr_badsession;
  1444. session = find_in_sessionid_hashtbl(&seq->sessionid);
  1445. if (!session)
  1446. goto out;
  1447. status = nfserr_badslot;
  1448. if (seq->slotid >= session->se_fchannel.maxreqs)
  1449. goto out;
  1450. slot = session->se_slots[seq->slotid];
  1451. dprintk("%s: slotid %d\n", __func__, seq->slotid);
  1452. /* We do not negotiate the number of slots yet, so set the
  1453. * maxslots to the session maxreqs which is used to encode
  1454. * sr_highest_slotid and the sr_target_slot id to maxslots */
  1455. seq->maxslots = session->se_fchannel.maxreqs;
  1456. status = check_slot_seqid(seq->seqid, slot->sl_seqid, slot->sl_inuse);
  1457. if (status == nfserr_replay_cache) {
  1458. cstate->slot = slot;
  1459. cstate->session = session;
  1460. /* Return the cached reply status and set cstate->status
  1461. * for nfsd4_proc_compound processing */
  1462. status = nfsd4_replay_cache_entry(resp, seq);
  1463. cstate->status = nfserr_replay_cache;
  1464. goto out;
  1465. }
  1466. if (status)
  1467. goto out;
  1468. nfsd4_sequence_check_conn(rqstp, session);
  1469. /* Success! bump slot seqid */
  1470. slot->sl_inuse = true;
  1471. slot->sl_seqid = seq->seqid;
  1472. slot->sl_cachethis = seq->cachethis;
  1473. cstate->slot = slot;
  1474. cstate->session = session;
  1475. out:
  1476. /* Hold a session reference until done processing the compound. */
  1477. if (cstate->session) {
  1478. nfsd4_get_session(cstate->session);
  1479. atomic_inc(&session->se_client->cl_refcount);
  1480. }
  1481. spin_unlock(&client_lock);
  1482. dprintk("%s: return %d\n", __func__, ntohl(status));
  1483. return status;
  1484. }
  1485. __be32
  1486. nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
  1487. {
  1488. if (rc->rca_one_fs) {
  1489. if (!cstate->current_fh.fh_dentry)
  1490. return nfserr_nofilehandle;
  1491. /*
  1492. * We don't take advantage of the rca_one_fs case.
  1493. * That's OK, it's optional, we can safely ignore it.
  1494. */
  1495. return nfs_ok;
  1496. }
  1497. nfs4_lock_state();
  1498. if (is_client_expired(cstate->session->se_client)) {
  1499. nfs4_unlock_state();
  1500. /*
  1501. * The following error isn't really legal.
  1502. * But we only get here if the client just explicitly
  1503. * destroyed the client. Surely it no longer cares what
  1504. * error it gets back on an operation for the dead
  1505. * client.
  1506. */
  1507. return nfserr_stale_clientid;
  1508. }
  1509. nfsd4_create_clid_dir(cstate->session->se_client);
  1510. nfs4_unlock_state();
  1511. return nfs_ok;
  1512. }
  1513. __be32
  1514. nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
  1515. struct nfsd4_setclientid *setclid)
  1516. {
  1517. struct sockaddr *sa = svc_addr(rqstp);
  1518. struct xdr_netobj clname = {
  1519. .len = setclid->se_namelen,
  1520. .data = setclid->se_name,
  1521. };
  1522. nfs4_verifier clverifier = setclid->se_verf;
  1523. unsigned int strhashval;
  1524. struct nfs4_client *conf, *unconf, *new;
  1525. __be32 status;
  1526. char dname[HEXDIR_LEN];
  1527. if (!check_name(clname))
  1528. return nfserr_inval;
  1529. status = nfs4_make_rec_clidname(dname, &clname);
  1530. if (status)
  1531. return status;
  1532. /*
  1533. * XXX The Duplicate Request Cache (DRC) has been checked (??)
  1534. * We get here on a DRC miss.
  1535. */
  1536. strhashval = clientstr_hashval(dname);
  1537. nfs4_lock_state();
  1538. conf = find_confirmed_client_by_str(dname, strhashval, false);
  1539. if (conf) {
  1540. /* RFC 3530 14.2.33 CASE 0: */
  1541. status = nfserr_clid_inuse;
  1542. if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
  1543. char addr_str[INET6_ADDRSTRLEN];
  1544. rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
  1545. sizeof(addr_str));
  1546. dprintk("NFSD: setclientid: string in use by client "
  1547. "at %s\n", addr_str);
  1548. goto out;
  1549. }
  1550. }
  1551. /*
  1552. * section 14.2.33 of RFC 3530 (under the heading "IMPLEMENTATION")
  1553. * has a description of SETCLIENTID request processing consisting
  1554. * of 5 bullet points, labeled as CASE0 - CASE4 below.
  1555. */
  1556. unconf = find_unconfirmed_client_by_str(dname, strhashval, false);
  1557. status = nfserr_resource;
  1558. if (!conf) {
  1559. /*
  1560. * RFC 3530 14.2.33 CASE 4:
  1561. * placed first, because it is the normal case
  1562. */
  1563. if (unconf)
  1564. expire_client(unconf);
  1565. new = create_client(clname, dname, rqstp, &clverifier);
  1566. if (new == NULL)
  1567. goto out;
  1568. gen_clid(new);
  1569. } else if (same_verf(&conf->cl_verifier, &clverifier)) {
  1570. /*
  1571. * RFC 3530 14.2.33 CASE 1:
  1572. * probable callback update
  1573. */
  1574. if (unconf) {
  1575. /* Note this is removing unconfirmed {*x***},
  1576. * which is stronger than RFC recommended {vxc**}.
  1577. * This has the advantage that there is at most
  1578. * one {*x***} in either list at any time.
  1579. */
  1580. expire_client(unconf);
  1581. }
  1582. new = create_client(clname, dname, rqstp, &clverifier);
  1583. if (new == NULL)
  1584. goto out;
  1585. copy_clid(new, conf);
  1586. } else if (!unconf) {
  1587. /*
  1588. * RFC 3530 14.2.33 CASE 2:
  1589. * probable client reboot; state will be removed if
  1590. * confirmed.
  1591. */
  1592. new = create_client(clname, dname, rqstp, &clverifier);
  1593. if (new == NULL)
  1594. goto out;
  1595. gen_clid(new);
  1596. } else {
  1597. /*
  1598. * RFC 3530 14.2.33 CASE 3:
  1599. * probable client reboot; state will be removed if
  1600. * confirmed.
  1601. */
  1602. expire_client(unconf);
  1603. new = create_client(clname, dname, rqstp, &clverifier);
  1604. if (new == NULL)
  1605. goto out;
  1606. gen_clid(new);
  1607. }
  1608. gen_callback(new, setclid, rpc_get_scope_id(sa));
  1609. add_to_unconfirmed(new, strhashval);
  1610. setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
  1611. setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
  1612. memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
  1613. status = nfs_ok;
  1614. out:
  1615. nfs4_unlock_state();
  1616. return status;
  1617. }
  1618. /*
  1619. * Section 14.2.34 of RFC 3530 (under the heading "IMPLEMENTATION") has
  1620. * a description of SETCLIENTID_CONFIRM request processing consisting of 4
  1621. * bullets, labeled as CASE1 - CASE4 below.
  1622. */
  1623. __be32
  1624. nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
  1625. struct nfsd4_compound_state *cstate,
  1626. struct nfsd4_setclientid_confirm *setclientid_confirm)
  1627. {
  1628. struct sockaddr *sa = svc_addr(rqstp);
  1629. struct nfs4_client *conf, *unconf;
  1630. nfs4_verifier confirm = setclientid_confirm->sc_confirm;
  1631. clientid_t * clid = &setclientid_confirm->sc_clientid;
  1632. __be32 status;
  1633. if (STALE_CLIENTID(clid))
  1634. return nfserr_stale_clientid;
  1635. /*
  1636. * XXX The Duplicate Request Cache (DRC) has been checked (??)
  1637. * We get here on a DRC miss.
  1638. */
  1639. nfs4_lock_state();
  1640. conf = find_confirmed_client(clid);
  1641. unconf = find_unconfirmed_client(clid);
  1642. status = nfserr_clid_inuse;
  1643. if (conf && !rpc_cmp_addr((struct sockaddr *) &conf->cl_addr, sa))
  1644. goto out;
  1645. if (unconf && !rpc_cmp_addr((struct sockaddr *) &unconf->cl_addr, sa))
  1646. goto out;
  1647. /*
  1648. * section 14.2.34 of RFC 3530 has a description of
  1649. * SETCLIENTID_CONFIRM request processing consisting
  1650. * of 4 bullet points, labeled as CASE1 - CASE4 below.
  1651. */
  1652. if (conf && unconf && same_verf(&confirm, &unconf->cl_confirm)) {
  1653. /*
  1654. * RFC 3530 14.2.34 CASE 1:
  1655. * callback update
  1656. */
  1657. if (!same_creds(&conf->cl_cred, &unconf->cl_cred))
  1658. status = nfserr_clid_inuse;
  1659. else {
  1660. atomic_set(&conf->cl_cb_set, 0);
  1661. nfsd4_probe_callback(conf, &unconf->cl_cb_conn);
  1662. expire_client(unconf);
  1663. status = nfs_ok;
  1664. }
  1665. } else if (conf && !unconf) {
  1666. /*
  1667. * RFC 3530 14.2.34 CASE 2:
  1668. * probable retransmitted request; play it safe and
  1669. * do nothing.
  1670. */
  1671. if (!same_creds(&conf->cl_cred, &rqstp->rq_cred))
  1672. status = nfserr_clid_inuse;
  1673. else
  1674. status = nfs_ok;
  1675. } else if (!conf && unconf
  1676. && same_verf(&unconf->cl_confirm, &confirm)) {
  1677. /*
  1678. * RFC 3530 14.2.34 CASE 3:
  1679. * Normal case; new or rebooted client:
  1680. */
  1681. if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred)) {
  1682. status = nfserr_clid_inuse;
  1683. } else {
  1684. unsigned int hash =
  1685. clientstr_hashval(unconf->cl_recdir);
  1686. conf = find_confirmed_client_by_str(unconf->cl_recdir,
  1687. hash, false);
  1688. if (conf) {
  1689. nfsd4_remove_clid_dir(conf);
  1690. expire_client(conf);
  1691. }
  1692. move_to_confirmed(unconf);
  1693. conf = unconf;
  1694. nfsd4_probe_callback(conf, &conf->cl_cb_conn);
  1695. status = nfs_ok;
  1696. }
  1697. } else if ((!conf || (conf && !same_verf(&conf->cl_confirm, &confirm)))
  1698. && (!unconf || (unconf && !same_verf(&unconf->cl_confirm,
  1699. &confirm)))) {
  1700. /*
  1701. * RFC 3530 14.2.34 CASE 4:
  1702. * Client probably hasn't noticed that we rebooted yet.
  1703. */
  1704. status = nfserr_stale_clientid;
  1705. } else {
  1706. /* check that we have hit one of the cases...*/
  1707. status = nfserr_clid_inuse;
  1708. }
  1709. out:
  1710. nfs4_unlock_state();
  1711. return status;
  1712. }
  1713. /* OPEN Share state helper functions */
  1714. static inline struct nfs4_file *
  1715. alloc_init_file(struct inode *ino)
  1716. {
  1717. struct nfs4_file *fp;
  1718. unsigned int hashval = file_hashval(ino);
  1719. fp = kmem_cache_alloc(file_slab, GFP_KERNEL);
  1720. if (fp) {
  1721. atomic_set(&fp->fi_ref, 1);
  1722. INIT_LIST_HEAD(&fp->fi_hash);
  1723. INIT_LIST_HEAD(&fp->fi_stateids);
  1724. INIT_LIST_HEAD(&fp->fi_delegations);
  1725. fp->fi_inode = igrab(ino);
  1726. fp->fi_id = current_fileid++;
  1727. fp->fi_had_conflict = false;
  1728. memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
  1729. memset(fp->fi_access, 0, sizeof(fp->fi_access));
  1730. spin_lock(&recall_lock);
  1731. list_add(&fp->fi_hash, &file_hashtbl[hashval]);
  1732. spin_unlock(&recall_lock);
  1733. return fp;
  1734. }
  1735. return NULL;
  1736. }
  1737. static void
  1738. nfsd4_free_slab(struct kmem_cache **slab)
  1739. {
  1740. if (*slab == NULL)
  1741. return;
  1742. kmem_cache_destroy(*slab);
  1743. *slab = NULL;
  1744. }
  1745. void
  1746. nfsd4_free_slabs(void)
  1747. {
  1748. nfsd4_free_slab(&stateowner_slab);
  1749. nfsd4_free_slab(&file_slab);
  1750. nfsd4_free_slab(&stateid_slab);
  1751. nfsd4_free_slab(&deleg_slab);
  1752. }
  1753. static int
  1754. nfsd4_init_slabs(void)
  1755. {
  1756. stateowner_slab = kmem_cache_create("nfsd4_stateowners",
  1757. sizeof(struct nfs4_stateowner), 0, 0, NULL);
  1758. if (stateowner_slab == NULL)
  1759. goto out_nomem;
  1760. file_slab = kmem_cache_create("nfsd4_files",
  1761. sizeof(struct nfs4_file), 0, 0, NULL);
  1762. if (file_slab == NULL)
  1763. goto out_nomem;
  1764. stateid_slab = kmem_cache_create("nfsd4_stateids",
  1765. sizeof(struct nfs4_stateid), 0, 0, NULL);
  1766. if (stateid_slab == NULL)
  1767. goto out_nomem;
  1768. deleg_slab = kmem_cache_create("nfsd4_delegations",
  1769. sizeof(struct nfs4_delegation), 0, 0, NULL);
  1770. if (deleg_slab == NULL)
  1771. goto out_nomem;
  1772. return 0;
  1773. out_nomem:
  1774. nfsd4_free_slabs();
  1775. dprintk("nfsd4: out of memory while initializing nfsv4\n");
  1776. return -ENOMEM;
  1777. }
  1778. void
  1779. nfs4_free_stateowner(struct kref *kref)
  1780. {
  1781. struct nfs4_stateowner *sop =
  1782. container_of(kref, struct nfs4_stateowner, so_ref);
  1783. kfree(sop->so_owner.data);
  1784. kmem_cache_free(stateowner_slab, sop);
  1785. }
  1786. static inline struct nfs4_stateowner *
  1787. alloc_stateowner(struct xdr_netobj *owner)
  1788. {
  1789. struct nfs4_stateowner *sop;
  1790. if ((sop = kmem_cache_alloc(stateowner_slab, GFP_KERNEL))) {
  1791. if ((sop->so_owner.data = kmalloc(owner->len, GFP_KERNEL))) {
  1792. memcpy(sop->so_owner.data, owner->data, owner->len);
  1793. sop->so_owner.len = owner->len;
  1794. kref_init(&sop->so_ref);
  1795. return sop;
  1796. }
  1797. kmem_cache_free(stateowner_slab, sop);
  1798. }
  1799. return NULL;
  1800. }
  1801. static struct nfs4_stateowner *
  1802. alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
  1803. struct nfs4_stateowner *sop;
  1804. struct nfs4_replay *rp;
  1805. unsigned int idhashval;
  1806. if (!(sop = alloc_stateowner(&open->op_owner)))
  1807. return NULL;
  1808. idhashval = ownerid_hashval(current_ownerid);
  1809. INIT_LIST_HEAD(&sop->so_idhash);
  1810. INIT_LIST_HEAD(&sop->so_strhash);
  1811. INIT_LIST_HEAD(&sop->so_perclient);
  1812. INIT_LIST_HEAD(&sop->so_stateids);
  1813. INIT_LIST_HEAD(&sop->so_perstateid); /* not used */
  1814. INIT_LIST_HEAD(&sop->so_close_lru);
  1815. sop->so_time = 0;
  1816. list_add(&sop->so_idhash, &ownerid_hashtbl[idhashval]);
  1817. list_add(&sop->so_strhash, &ownerstr_hashtbl[strhashval]);
  1818. list_add(&sop->so_perclient, &clp->cl_openowners);
  1819. sop->so_is_open_owner = 1;
  1820. sop->so_id = current_ownerid++;
  1821. sop->so_client = clp;
  1822. sop->so_seqid = open->op_seqid;
  1823. sop->so_confirmed = 0;
  1824. rp = &sop->so_replay;
  1825. rp->rp_status = nfserr_serverfault;
  1826. rp->rp_buflen = 0;
  1827. rp->rp_buf = rp->rp_ibuf;
  1828. return sop;
  1829. }
  1830. static inline void
  1831. init_stateid(struct nfs4_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) {
  1832. struct nfs4_stateowner *sop = open->op_stateowner;
  1833. unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);
  1834. INIT_LIST_HEAD(&stp->st_hash);
  1835. INIT_LIST_HEAD(&stp->st_perstateowner);
  1836. INIT_LIST_HEAD(&stp->st_lockowners);
  1837. INIT_LIST_HEAD(&stp->st_perfile);
  1838. list_add(&stp->st_hash, &stateid_hashtbl[hashval]);
  1839. list_add(&stp->st_perstateowner, &sop->so_stateids);
  1840. list_add(&stp->st_perfile, &fp->fi_stateids);
  1841. stp->st_stateowner = sop;
  1842. get_nfs4_file(fp);
  1843. stp->st_file = fp;
  1844. stp->st_stateid.si_boot = boot_time;
  1845. stp->st_stateid.si_stateownerid = sop->so_id;
  1846. stp->st_stateid.si_fileid = fp->fi_id;
  1847. stp->st_stateid.si_generation = 0;
  1848. stp->st_access_bmap = 0;
  1849. stp->st_deny_bmap = 0;
  1850. __set_bit(open->op_share_access & ~NFS4_SHARE_WANT_MASK,
  1851. &stp->st_access_bmap);
  1852. __set_bit(open->op_share_deny, &stp->st_deny_bmap);
  1853. stp->st_openstp = NULL;
  1854. }
  1855. static void
  1856. move_to_close_lru(struct nfs4_stateowner *sop)
  1857. {
  1858. dprintk("NFSD: move_to_close_lru nfs4_stateowner %p\n", sop);
  1859. list_move_tail(&sop->so_close_lru, &close_lru);
  1860. sop->so_time = get_seconds();
  1861. }
  1862. static int
  1863. same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner,
  1864. clientid_t *clid)
  1865. {
  1866. return (sop->so_owner.len == owner->len) &&
  1867. 0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&
  1868. (sop->so_client->cl_clientid.cl_id == clid->cl_id);
  1869. }
  1870. static struct nfs4_stateowner *
  1871. find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open)
  1872. {
  1873. struct nfs4_stateowner *so = NULL;
  1874. list_for_each_entry(so, &ownerstr_hashtbl[hashval], so_strhash) {
  1875. if (same_owner_str(so, &open->op_owner, &open->op_clientid))
  1876. return so;
  1877. }
  1878. return NULL;
  1879. }
  1880. /* search file_hashtbl[] for file */
  1881. static struct nfs4_file *
  1882. find_file(struct inode *ino)
  1883. {
  1884. unsigned int hashval = file_hashval(ino);
  1885. struct nfs4_file *fp;
  1886. spin_lock(&recall_lock);
  1887. list_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
  1888. if (fp->fi_inode == ino) {
  1889. get_nfs4_file(fp);
  1890. spin_unlock(&recall_lock);
  1891. return fp;
  1892. }
  1893. }
  1894. spin_unlock(&recall_lock);
  1895. return NULL;
  1896. }
  1897. static inline int access_valid(u32 x, u32 minorversion)
  1898. {
  1899. if ((x & NFS4_SHARE_ACCESS_MASK) < NFS4_SHARE_ACCESS_READ)
  1900. return 0;
  1901. if ((x & NFS4_SHARE_ACCESS_MASK) > NFS4_SHARE_ACCESS_BOTH)
  1902. return 0;
  1903. x &= ~NFS4_SHARE_ACCESS_MASK;
  1904. if (minorversion && x) {
  1905. if ((x & NFS4_SHARE_WANT_MASK) > NFS4_SHARE_WANT_CANCEL)
  1906. return 0;
  1907. if ((x & NFS4_SHARE_WHEN_MASK) > NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED)
  1908. return 0;
  1909. x &= ~(NFS4_SHARE_WANT_MASK | NFS4_SHARE_WHEN_MASK);
  1910. }
  1911. if (x)
  1912. return 0;
  1913. return 1;
  1914. }
  1915. static inline int deny_valid(u32 x)
  1916. {
  1917. /* Note: unlike access bits, deny bits may be zero. */
  1918. return x <= NFS4_SHARE_DENY_BOTH;
  1919. }
  1920. /*
  1921. * Called to check deny when READ with all zero stateid or
  1922. * WRITE with all zero or all one stateid
  1923. */
  1924. static __be32
  1925. nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
  1926. {
  1927. struct inode *ino = current_fh->fh_dentry->d_inode;
  1928. struct nfs4_file *fp;
  1929. struct nfs4_stateid *stp;
  1930. __be32 ret;
  1931. dprintk("NFSD: nfs4_share_conflict\n");
  1932. fp = find_file(ino);
  1933. if (!fp)
  1934. return nfs_ok;
  1935. ret = nfserr_locked;
  1936. /* Search for conflicting share reservations */
  1937. list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
  1938. if (test_bit(deny_type, &stp->st_deny_bmap) ||
  1939. test_bit(NFS4_SHARE_DENY_BOTH, &stp->st_deny_bmap))
  1940. goto out;
  1941. }
  1942. ret = nfs_ok;
  1943. out:
  1944. put_nfs4_file(fp);
  1945. return ret;
  1946. }
  1947. static inline void
  1948. nfs4_file_downgrade(struct nfs4_file *fp, unsigned int share_access)
  1949. {
  1950. if (share_access & NFS4_SHARE_ACCESS_WRITE)
  1951. nfs4_file_put_access(fp, O_WRONLY);
  1952. if (share_access & NFS4_SHARE_ACCESS_READ)
  1953. nfs4_file_put_access(fp, O_RDONLY);
  1954. }
  1955. /*
  1956. * Spawn a thread to perform a recall on the delegation represented
  1957. * by the lease (file_lock)
  1958. *
  1959. * Called from break_lease() with lock_kernel() held.
  1960. * Note: we assume break_lease will only call this *once* for any given
  1961. * lease.
  1962. */
  1963. static
  1964. void nfsd_break_deleg_cb(struct file_lock *fl)
  1965. {
  1966. struct nfs4_delegation *dp = (struct nfs4_delegation *)fl->fl_owner;
  1967. dprintk("NFSD nfsd_break_deleg_cb: dp %p fl %p\n",dp,fl);
  1968. if (!dp)
  1969. return;
  1970. /* We're assuming the state code never drops its reference
  1971. * without first removing the lease. Since we're in this lease
  1972. * callback (and since the lease code is serialized by the kernel
  1973. * lock) we know the server hasn't removed the lease yet, we know
  1974. * it's safe to take a reference: */
  1975. atomic_inc(&dp->dl_count);
  1976. spin_lock(&recall_lock);
  1977. list_add_tail(&dp->dl_recall_lru, &del_recall_lru);
  1978. spin_unlock(&recall_lock);
  1979. /* only place dl_time is set. protected by lock_kernel*/
  1980. dp->dl_time = get_seconds();
  1981. /*
  1982. * We don't want the locks code to timeout the lease for us;
  1983. * we'll remove it ourself if the delegation isn't returned
  1984. * in time.
  1985. */
  1986. fl->fl_break_time = 0;
  1987. dp->dl_file->fi_had_conflict = true;
  1988. nfsd4_cb_recall(dp);
  1989. }
  1990. /*
  1991. * The file_lock is being reapd.
  1992. *
  1993. * Called by locks_free_lock() with lock_kernel() held.
  1994. */
  1995. static
  1996. void nfsd_release_deleg_cb(struct file_lock *fl)
  1997. {
  1998. struct nfs4_delegation *dp = (struct nfs4_delegation *)fl->fl_owner;
  1999. dprintk("NFSD nfsd_release_deleg_cb: fl %p dp %p dl_count %d\n", fl,dp, atomic_read(&dp->dl_count));
  2000. if (!(fl->fl_flags & FL_LEASE) || !dp)
  2001. return;
  2002. dp->dl_flock = NULL;
  2003. }
  2004. /*
  2005. * Set the delegation file_lock back pointer.
  2006. *
  2007. * Called from setlease() with lock_kernel() held.
  2008. */
  2009. static
  2010. void nfsd_copy_lock_deleg_cb(struct file_lock *new, struct file_lock *fl)
  2011. {
  2012. struct nfs4_delegation *dp = (struct nfs4_delegation *)new->fl_owner;
  2013. dprintk("NFSD: nfsd_copy_lock_deleg_cb: new fl %p dp %p\n", new, dp);
  2014. if (!dp)
  2015. return;
  2016. dp->dl_flock = new;
  2017. }
  2018. /*
  2019. * Called from setlease() with lock_kernel() held
  2020. */
  2021. static
  2022. int nfsd_same_client_deleg_cb(struct file_lock *onlist, struct file_lock *try)
  2023. {
  2024. struct nfs4_delegation *onlistd =
  2025. (struct nfs4_delegation *)onlist->fl_owner;
  2026. struct nfs4_delegation *tryd =
  2027. (struct nfs4_delegation *)try->fl_owner;
  2028. if (onlist->fl_lmops != try->fl_lmops)
  2029. return 0;
  2030. return onlistd->dl_client == tryd->dl_client;
  2031. }
  2032. static
  2033. int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
  2034. {
  2035. if (arg & F_UNLCK)
  2036. return lease_modify(onlist, arg);
  2037. else
  2038. return -EAGAIN;
  2039. }
  2040. static const struct lock_manager_operations nfsd_lease_mng_ops = {
  2041. .fl_break = nfsd_break_deleg_cb,
  2042. .fl_release_private = nfsd_release_deleg_cb,
  2043. .fl_copy_lock = nfsd_copy_lock_deleg_cb,
  2044. .fl_mylease = nfsd_same_client_deleg_cb,
  2045. .fl_change = nfsd_change_deleg_cb,
  2046. };
  2047. __be32
  2048. nfsd4_process_open1(struct nfsd4_compound_state *cstate,
  2049. struct nfsd4_open *open)
  2050. {
  2051. clientid_t *clientid = &open->op_clientid;
  2052. struct nfs4_client *clp = NULL;
  2053. unsigned int strhashval;
  2054. struct nfs4_stateowner *sop = NULL;
  2055. if (!check_name(open->op_owner))
  2056. return nfserr_inval;
  2057. if (STALE_CLIENTID(&open->op_clientid))
  2058. return nfserr_stale_clientid;
  2059. strhashval = ownerstr_hashval(clientid->cl_id, open->op_owner);
  2060. sop = find_openstateowner_str(strhashval, open);
  2061. open->op_stateowner = sop;
  2062. if (!sop) {
  2063. /* Make sure the client's lease hasn't expired. */
  2064. clp = find_confirmed_client(clientid);
  2065. if (clp == NULL)
  2066. return nfserr_expired;
  2067. goto renew;
  2068. }
  2069. /* When sessions are used, skip open sequenceid processing */
  2070. if (nfsd4_has_session(cstate))
  2071. goto renew;
  2072. if (!sop->so_confirmed) {
  2073. /* Replace unconfirmed owners without checking for replay. */
  2074. clp = sop->so_client;
  2075. release_openowner(sop);
  2076. open->op_stateowner = NULL;
  2077. goto renew;
  2078. }
  2079. if (open->op_seqid == sop->so_seqid - 1) {
  2080. if (sop->so_replay.rp_buflen)
  2081. return nfserr_replay_me;
  2082. /* The original OPEN failed so spectacularly
  2083. * that we don't even have replay data saved!
  2084. * Therefore, we have no choice but to continue
  2085. * processing this OPEN; presumably, we'll
  2086. * fail again for the same reason.
  2087. */
  2088. dprintk("nfsd4_process_open1: replay with no replay cache\n");
  2089. goto renew;
  2090. }
  2091. if (open->op_seqid != sop->so_seqid)
  2092. return nfserr_bad_seqid;
  2093. renew:
  2094. if (open->op_stateowner == NULL) {
  2095. sop = alloc_init_open_stateowner(strhashval, clp, open);
  2096. if (sop == NULL)
  2097. return nfserr_resource;
  2098. open->op_stateowner = sop;
  2099. }
  2100. list_del_init(&sop->so_close_lru);
  2101. renew_client(sop->so_client);
  2102. return nfs_ok;
  2103. }
  2104. static inline __be32
  2105. nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
  2106. {
  2107. if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
  2108. return nfserr_openmode;
  2109. else
  2110. return nfs_ok;
  2111. }
  2112. static struct nfs4_delegation *
  2113. find_delegation_file(struct nfs4_file *fp, stateid_t *stid)
  2114. {
  2115. struct nfs4_delegation *dp;
  2116. list_for_each_entry(dp, &fp->fi_delegations, dl_perfile) {
  2117. if (dp->dl_stateid.si_stateownerid == stid->si_stateownerid)
  2118. return dp;
  2119. }
  2120. return NULL;
  2121. }
  2122. int share_access_to_flags(u32 share_access)
  2123. {
  2124. share_access &= ~NFS4_SHARE_WANT_MASK;
  2125. return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
  2126. }
  2127. static __be32
  2128. nfs4_check_deleg(struct nfs4_file *fp, struct nfsd4_open *open,
  2129. struct nfs4_delegation **dp)
  2130. {
  2131. int flags;
  2132. __be32 status = nfserr_bad_stateid;
  2133. *dp = find_delegation_file(fp, &open->op_delegate_stateid);
  2134. if (*dp == NULL)
  2135. goto out;
  2136. flags = share_access_to_flags(open->op_share_access);
  2137. status = nfs4_check_delegmode(*dp, flags);
  2138. if (status)
  2139. *dp = NULL;
  2140. out:
  2141. if (open->op_claim_type != NFS4_OPEN_CLAIM_DELEGATE_CUR)
  2142. return nfs_ok;
  2143. if (status)
  2144. return status;
  2145. open->op_stateowner->so_confirmed = 1;
  2146. return nfs_ok;
  2147. }
  2148. static __be32
  2149. nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_stateid **stpp)
  2150. {
  2151. struct nfs4_stateid *local;
  2152. __be32 status = nfserr_share_denied;
  2153. struct nfs4_stateowner *sop = open->op_stateowner;
  2154. list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
  2155. /* ignore lock owners */
  2156. if (local->st_stateowner->so_is_open_owner == 0)
  2157. continue;
  2158. /* remember if we have seen this open owner */
  2159. if (local->st_stateowner == sop)
  2160. *stpp = local;
  2161. /* check for conflicting share reservations */
  2162. if (!test_share(local, open))
  2163. goto out;
  2164. }
  2165. status = 0;
  2166. out:
  2167. return status;
  2168. }
  2169. static inline struct nfs4_stateid *
  2170. nfs4_alloc_stateid(void)
  2171. {
  2172. return kmem_cache_alloc(stateid_slab, GFP_KERNEL);
  2173. }
  2174. static inline int nfs4_access_to_access(u32 nfs4_access)
  2175. {
  2176. int flags = 0;
  2177. if (nfs4_access & NFS4_SHARE_ACCESS_READ)
  2178. flags |= NFSD_MAY_READ;
  2179. if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
  2180. flags |= NFSD_MAY_WRITE;
  2181. return flags;
  2182. }
  2183. static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file
  2184. *fp, struct svc_fh *cur_fh, u32 nfs4_access)
  2185. {
  2186. __be32 status;
  2187. int oflag = nfs4_access_to_omode(nfs4_access);
  2188. int access = nfs4_access_to_access(nfs4_access);
  2189. if (!fp->fi_fds[oflag]) {
  2190. status = nfsd_open(rqstp, cur_fh, S_IFREG, access,
  2191. &fp->fi_fds[oflag]);
  2192. if (status == nfserr_dropit)
  2193. status = nfserr_jukebox;
  2194. if (status)
  2195. return status;
  2196. }
  2197. nfs4_file_get_access(fp, oflag);
  2198. return nfs_ok;
  2199. }
  2200. static __be32
  2201. nfs4_new_open(struct svc_rqst *rqstp, struct nfs4_stateid **stpp,
  2202. struct nfs4_file *fp, struct svc_fh *cur_fh,
  2203. struct nfsd4_open *open)
  2204. {
  2205. struct nfs4_stateid *stp;
  2206. __be32 status;
  2207. stp = nfs4_alloc_stateid();
  2208. if (stp == NULL)
  2209. return nfserr_resource;
  2210. status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open->op_share_access);
  2211. if (status) {
  2212. kmem_cache_free(stateid_slab, stp);
  2213. return status;
  2214. }
  2215. *stpp = stp;
  2216. return 0;
  2217. }
  2218. static inline __be32
  2219. nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
  2220. struct nfsd4_open *open)
  2221. {
  2222. struct iattr iattr = {
  2223. .ia_valid = ATTR_SIZE,
  2224. .ia_size = 0,
  2225. };
  2226. if (!open->op_truncate)
  2227. return 0;
  2228. if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
  2229. return nfserr_inval;
  2230. return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
  2231. }
  2232. static __be32
  2233. nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp, struct svc_fh *cur_fh, struct nfs4_stateid *stp, struct nfsd4_open *open)
  2234. {
  2235. u32 op_share_access = open->op_share_access & ~NFS4_SHARE_WANT_MASK;
  2236. bool new_access;
  2237. __be32 status;
  2238. new_access = !test_bit(op_share_access, &stp->st_access_bmap);
  2239. if (new_access) {
  2240. status = nfs4_get_vfs_file(rqstp, fp, cur_fh, op_share_access);
  2241. if (status)
  2242. return status;
  2243. }
  2244. status = nfsd4_truncate(rqstp, cur_fh, open);
  2245. if (status) {
  2246. if (new_access) {
  2247. int oflag = nfs4_access_to_omode(new_access);
  2248. nfs4_file_put_access(fp, oflag);
  2249. }
  2250. return status;
  2251. }
  2252. /* remember the open */
  2253. __set_bit(op_share_access, &stp->st_access_bmap);
  2254. __set_bit(open->op_share_deny, &stp->st_deny_bmap);
  2255. return nfs_ok;
  2256. }
  2257. static void
  2258. nfs4_set_claim_prev(struct nfsd4_open *open)
  2259. {
  2260. open->op_stateowner->so_confirmed = 1;
  2261. open->op_stateowner->so_client->cl_firststate = 1;
  2262. }
  2263. /*
  2264. * Attempt to hand out a delegation.
  2265. */
  2266. static void
  2267. nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open, struct nfs4_stateid *stp)
  2268. {
  2269. struct nfs4_delegation *dp;
  2270. struct nfs4_stateowner *sop = stp->st_stateowner;
  2271. int cb_up = atomic_read(&sop->so_client->cl_cb_set);
  2272. struct file_lock fl, *flp = &fl;
  2273. int status, flag = 0;
  2274. flag = NFS4_OPEN_DELEGATE_NONE;
  2275. open->op_recall = 0;
  2276. switch (open->op_claim_type) {
  2277. case NFS4_OPEN_CLAIM_PREVIOUS:
  2278. if (!cb_up)
  2279. open->op_recall = 1;
  2280. flag = open->op_delegate_type;
  2281. if (flag == NFS4_OPEN_DELEGATE_NONE)
  2282. goto out;
  2283. break;
  2284. case NFS4_OPEN_CLAIM_NULL:
  2285. /* Let's not give out any delegations till everyone's
  2286. * had the chance to reclaim theirs.... */
  2287. if (locks_in_grace())
  2288. goto out;
  2289. if (!cb_up || !sop->so_confirmed)
  2290. goto out;
  2291. if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
  2292. flag = NFS4_OPEN_DELEGATE_WRITE;
  2293. else
  2294. flag = NFS4_OPEN_DELEGATE_READ;
  2295. break;
  2296. default:
  2297. goto out;
  2298. }
  2299. dp = alloc_init_deleg(sop->so_client, stp, fh, flag);
  2300. if (dp == NULL) {
  2301. flag = NFS4_OPEN_DELEGATE_NONE;
  2302. goto out;
  2303. }
  2304. locks_init_lock(&fl);
  2305. fl.fl_lmops = &nfsd_lease_mng_ops;
  2306. fl.fl_flags = FL_LEASE;
  2307. fl.fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
  2308. fl.fl_end = OFFSET_MAX;
  2309. fl.fl_owner = (fl_owner_t)dp;
  2310. fl.fl_file = find_readable_file(stp->st_file);
  2311. BUG_ON(!fl.fl_file);
  2312. fl.fl_pid = current->tgid;
  2313. /* vfs_setlease checks to see if delegation should be handed out.
  2314. * the lock_manager callbacks fl_mylease and fl_change are used
  2315. */
  2316. if ((status = vfs_setlease(fl.fl_file, fl.fl_type, &flp))) {
  2317. dprintk("NFSD: setlease failed [%d], no delegation\n", status);
  2318. unhash_delegation(dp);
  2319. flag = NFS4_OPEN_DELEGATE_NONE;
  2320. goto out;
  2321. }
  2322. memcpy(&open->op_delegate_stateid, &dp->dl_stateid, sizeof(dp->dl_stateid));
  2323. dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
  2324. STATEID_VAL(&dp->dl_stateid));
  2325. out:
  2326. if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS
  2327. && flag == NFS4_OPEN_DELEGATE_NONE
  2328. && open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE)
  2329. dprintk("NFSD: WARNING: refusing delegation reclaim\n");
  2330. open->op_delegate_type = flag;
  2331. }
  2332. /*
  2333. * called with nfs4_lock_state() held.
  2334. */
  2335. __be32
  2336. nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
  2337. {
  2338. struct nfsd4_compoundres *resp = rqstp->rq_resp;
  2339. struct nfs4_file *fp = NULL;
  2340. struct inode *ino = current_fh->fh_dentry->d_inode;
  2341. struct nfs4_stateid *stp = NULL;
  2342. struct nfs4_delegation *dp = NULL;
  2343. __be32 status;
  2344. status = nfserr_inval;
  2345. if (!access_valid(open->op_share_access, resp->cstate.minorversion)
  2346. || !deny_valid(open->op_share_deny))
  2347. goto out;
  2348. /*
  2349. * Lookup file; if found, lookup stateid and check open request,
  2350. * and check for delegations in the process of being recalled.
  2351. * If not found, create the nfs4_file struct
  2352. */
  2353. fp = find_file(ino);
  2354. if (fp) {
  2355. if ((status = nfs4_check_open(fp, open, &stp)))
  2356. goto out;
  2357. status = nfs4_check_deleg(fp, open, &dp);
  2358. if (status)
  2359. goto out;
  2360. } else {
  2361. status = nfserr_bad_stateid;
  2362. if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
  2363. goto out;
  2364. status = nfserr_resource;
  2365. fp = alloc_init_file(ino);
  2366. if (fp == NULL)
  2367. goto out;
  2368. }
  2369. /*
  2370. * OPEN the file, or upgrade an existing OPEN.
  2371. * If truncate fails, the OPEN fails.
  2372. */
  2373. if (stp) {
  2374. /* Stateid was found, this is an OPEN upgrade */
  2375. status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
  2376. if (status)
  2377. goto out;
  2378. update_stateid(&stp->st_stateid);
  2379. } else {
  2380. status = nfs4_new_open(rqstp, &stp, fp, current_fh, open);
  2381. if (status)
  2382. goto out;
  2383. init_stateid(stp, fp, open);
  2384. status = nfsd4_truncate(rqstp, current_fh, open);
  2385. if (status) {
  2386. release_open_stateid(stp);
  2387. goto out;
  2388. }
  2389. if (nfsd4_has_session(&resp->cstate))
  2390. update_stateid(&stp->st_stateid);
  2391. }
  2392. memcpy(&open->op_stateid, &stp->st_stateid, sizeof(stateid_t));
  2393. if (nfsd4_has_session(&resp->cstate))
  2394. open->op_stateowner->so_confirmed = 1;
  2395. /*
  2396. * Attempt to hand out a delegation. No error return, because the
  2397. * OPEN succeeds even if we fail.
  2398. */
  2399. nfs4_open_delegation(current_fh, open, stp);
  2400. status = nfs_ok;
  2401. dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
  2402. STATEID_VAL(&stp->st_stateid));
  2403. out:
  2404. if (fp)
  2405. put_nfs4_file(fp);
  2406. if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
  2407. nfs4_set_claim_prev(open);
  2408. /*
  2409. * To finish the open response, we just need to set the rflags.
  2410. */
  2411. open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
  2412. if (!open->op_stateowner->so_confirmed &&
  2413. !nfsd4_has_session(&resp->cstate))
  2414. open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
  2415. return status;
  2416. }
  2417. __be32
  2418. nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
  2419. clientid_t *clid)
  2420. {
  2421. struct nfs4_client *clp;
  2422. __be32 status;
  2423. nfs4_lock_state();
  2424. dprintk("process_renew(%08x/%08x): starting\n",
  2425. clid->cl_boot, clid->cl_id);
  2426. status = nfserr_stale_clientid;
  2427. if (STALE_CLIENTID(clid))
  2428. goto out;
  2429. clp = find_confirmed_client(clid);
  2430. status = nfserr_expired;
  2431. if (clp == NULL) {
  2432. /* We assume the client took too long to RENEW. */
  2433. dprintk("nfsd4_renew: clientid not found!\n");
  2434. goto out;
  2435. }
  2436. renew_client(clp);
  2437. status = nfserr_cb_path_down;
  2438. if (!list_empty(&clp->cl_delegations)
  2439. && !atomic_read(&clp->cl_cb_set))
  2440. goto out;
  2441. status = nfs_ok;
  2442. out:
  2443. nfs4_unlock_state();
  2444. return status;
  2445. }
  2446. struct lock_manager nfsd4_manager = {
  2447. };
  2448. static void
  2449. nfsd4_end_grace(void)
  2450. {
  2451. dprintk("NFSD: end of grace period\n");
  2452. nfsd4_recdir_purge_old();
  2453. locks_end_grace(&nfsd4_manager);
  2454. /*
  2455. * Now that every NFSv4 client has had the chance to recover and
  2456. * to see the (possibly new, possibly shorter) lease time, we
  2457. * can safely set the next grace time to the current lease time:
  2458. */
  2459. nfsd4_grace = nfsd4_lease;
  2460. }
  2461. static time_t
  2462. nfs4_laundromat(void)
  2463. {
  2464. struct nfs4_client *clp;
  2465. struct nfs4_stateowner *sop;
  2466. struct nfs4_delegation *dp;
  2467. struct list_head *pos, *next, reaplist;
  2468. time_t cutoff = get_seconds() - nfsd4_lease;
  2469. time_t t, clientid_val = nfsd4_lease;
  2470. time_t u, test_val = nfsd4_lease;
  2471. nfs4_lock_state();
  2472. dprintk("NFSD: laundromat service - starting\n");
  2473. if (locks_in_grace())
  2474. nfsd4_end_grace();
  2475. INIT_LIST_HEAD(&reaplist);
  2476. spin_lock(&client_lock);
  2477. list_for_each_safe(pos, next, &client_lru) {
  2478. clp = list_entry(pos, struct nfs4_client, cl_lru);
  2479. if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
  2480. t = clp->cl_time - cutoff;
  2481. if (clientid_val > t)
  2482. clientid_val = t;
  2483. break;
  2484. }
  2485. if (atomic_read(&clp->cl_refcount)) {
  2486. dprintk("NFSD: client in use (clientid %08x)\n",
  2487. clp->cl_clientid.cl_id);
  2488. continue;
  2489. }
  2490. unhash_client_locked(clp);
  2491. list_add(&clp->cl_lru, &reaplist);
  2492. }
  2493. spin_unlock(&client_lock);
  2494. list_for_each_safe(pos, next, &reaplist) {
  2495. clp = list_entry(pos, struct nfs4_client, cl_lru);
  2496. dprintk("NFSD: purging unused client (clientid %08x)\n",
  2497. clp->cl_clientid.cl_id);
  2498. nfsd4_remove_clid_dir(clp);
  2499. expire_client(clp);
  2500. }
  2501. spin_lock(&recall_lock);
  2502. list_for_each_safe(pos, next, &del_recall_lru) {
  2503. dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
  2504. if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
  2505. u = dp->dl_time - cutoff;
  2506. if (test_val > u)
  2507. test_val = u;
  2508. break;
  2509. }
  2510. dprintk("NFSD: purging unused delegation dp %p, fp %p\n",
  2511. dp, dp->dl_flock);
  2512. list_move(&dp->dl_recall_lru, &reaplist);
  2513. }
  2514. spin_unlock(&recall_lock);
  2515. list_for_each_safe(pos, next, &reaplist) {
  2516. dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
  2517. list_del_init(&dp->dl_recall_lru);
  2518. unhash_delegation(dp);
  2519. }
  2520. test_val = nfsd4_lease;
  2521. list_for_each_safe(pos, next, &close_lru) {
  2522. sop = list_entry(pos, struct nfs4_stateowner, so_close_lru);
  2523. if (time_after((unsigned long)sop->so_time, (unsigned long)cutoff)) {
  2524. u = sop->so_time - cutoff;
  2525. if (test_val > u)
  2526. test_val = u;
  2527. break;
  2528. }
  2529. dprintk("NFSD: purging unused open stateowner (so_id %d)\n",
  2530. sop->so_id);
  2531. release_openowner(sop);
  2532. }
  2533. if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT)
  2534. clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT;
  2535. nfs4_unlock_state();
  2536. return clientid_val;
  2537. }
  2538. static struct workqueue_struct *laundry_wq;
  2539. static void laundromat_main(struct work_struct *);
  2540. static DECLARE_DELAYED_WORK(laundromat_work, laundromat_main);
  2541. static void
  2542. laundromat_main(struct work_struct *not_used)
  2543. {
  2544. time_t t;
  2545. t = nfs4_laundromat();
  2546. dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
  2547. queue_delayed_work(laundry_wq, &laundromat_work, t*HZ);
  2548. }
  2549. static struct nfs4_stateowner *
  2550. search_close_lru(u32 st_id, int flags)
  2551. {
  2552. struct nfs4_stateowner *local = NULL;
  2553. if (flags & CLOSE_STATE) {
  2554. list_for_each_entry(local, &close_lru, so_close_lru) {
  2555. if (local->so_id == st_id)
  2556. return local;
  2557. }
  2558. }
  2559. return NULL;
  2560. }
  2561. static inline int
  2562. nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stateid *stp)
  2563. {
  2564. return fhp->fh_dentry->d_inode != stp->st_file->fi_inode;
  2565. }
  2566. static int
  2567. STALE_STATEID(stateid_t *stateid)
  2568. {
  2569. if (stateid->si_boot == boot_time)
  2570. return 0;
  2571. dprintk("NFSD: stale stateid " STATEID_FMT "!\n",
  2572. STATEID_VAL(stateid));
  2573. return 1;
  2574. }
  2575. static inline int
  2576. access_permit_read(unsigned long access_bmap)
  2577. {
  2578. return test_bit(NFS4_SHARE_ACCESS_READ, &access_bmap) ||
  2579. test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap) ||
  2580. test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap);
  2581. }
  2582. static inline int
  2583. access_permit_write(unsigned long access_bmap)
  2584. {
  2585. return test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap) ||
  2586. test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap);
  2587. }
  2588. static
  2589. __be32 nfs4_check_openmode(struct nfs4_stateid *stp, int flags)
  2590. {
  2591. __be32 status = nfserr_openmode;
  2592. /* For lock stateid's, we test the parent open, not the lock: */
  2593. if (stp->st_openstp)
  2594. stp = stp->st_openstp;
  2595. if ((flags & WR_STATE) && (!access_permit_write(stp->st_access_bmap)))
  2596. goto out;
  2597. if ((flags & RD_STATE) && (!access_permit_read(stp->st_access_bmap)))
  2598. goto out;
  2599. status = nfs_ok;
  2600. out:
  2601. return status;
  2602. }
  2603. static inline __be32
  2604. check_special_stateids(svc_fh *current_fh, stateid_t *stateid, int flags)
  2605. {
  2606. if (ONE_STATEID(stateid) && (flags & RD_STATE))
  2607. return nfs_ok;
  2608. else if (locks_in_grace()) {
  2609. /* Answer in remaining cases depends on existance of
  2610. * conflicting state; so we must wait out the grace period. */
  2611. return nfserr_grace;
  2612. } else if (flags & WR_STATE)
  2613. return nfs4_share_conflict(current_fh,
  2614. NFS4_SHARE_DENY_WRITE);
  2615. else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
  2616. return nfs4_share_conflict(current_fh,
  2617. NFS4_SHARE_DENY_READ);
  2618. }
  2619. /*
  2620. * Allow READ/WRITE during grace period on recovered state only for files
  2621. * that are not able to provide mandatory locking.
  2622. */
  2623. static inline int
  2624. grace_disallows_io(struct inode *inode)
  2625. {
  2626. return locks_in_grace() && mandatory_lock(inode);
  2627. }
  2628. static int check_stateid_generation(stateid_t *in, stateid_t *ref, int flags)
  2629. {
  2630. /*
  2631. * When sessions are used the stateid generation number is ignored
  2632. * when it is zero.
  2633. */
  2634. if ((flags & HAS_SESSION) && in->si_generation == 0)
  2635. goto out;
  2636. /* If the client sends us a stateid from the future, it's buggy: */
  2637. if (in->si_generation > ref->si_generation)
  2638. return nfserr_bad_stateid;
  2639. /*
  2640. * The following, however, can happen. For example, if the
  2641. * client sends an open and some IO at the same time, the open
  2642. * may bump si_generation while the IO is still in flight.
  2643. * Thanks to hard links and renames, the client never knows what
  2644. * file an open will affect. So it could avoid that situation
  2645. * only by serializing all opens and IO from the same open
  2646. * owner. To recover from the old_stateid error, the client
  2647. * will just have to retry the IO:
  2648. */
  2649. if (in->si_generation < ref->si_generation)
  2650. return nfserr_old_stateid;
  2651. out:
  2652. return nfs_ok;
  2653. }
  2654. static int is_delegation_stateid(stateid_t *stateid)
  2655. {
  2656. return stateid->si_fileid == 0;
  2657. }
  2658. /*
  2659. * Checks for stateid operations
  2660. */
  2661. __be32
  2662. nfs4_preprocess_stateid_op(struct nfsd4_compound_state *cstate,
  2663. stateid_t *stateid, int flags, struct file **filpp)
  2664. {
  2665. struct nfs4_stateid *stp = NULL;
  2666. struct nfs4_delegation *dp = NULL;
  2667. struct svc_fh *current_fh = &cstate->current_fh;
  2668. struct inode *ino = current_fh->fh_dentry->d_inode;
  2669. __be32 status;
  2670. if (filpp)
  2671. *filpp = NULL;
  2672. if (grace_disallows_io(ino))
  2673. return nfserr_grace;
  2674. if (nfsd4_has_session(cstate))
  2675. flags |= HAS_SESSION;
  2676. if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
  2677. return check_special_stateids(current_fh, stateid, flags);
  2678. status = nfserr_stale_stateid;
  2679. if (STALE_STATEID(stateid))
  2680. goto out;
  2681. status = nfserr_bad_stateid;
  2682. if (is_delegation_stateid(stateid)) {
  2683. dp = find_delegation_stateid(ino, stateid);
  2684. if (!dp)
  2685. goto out;
  2686. status = check_stateid_generation(stateid, &dp->dl_stateid,
  2687. flags);
  2688. if (status)
  2689. goto out;
  2690. status = nfs4_check_delegmode(dp, flags);
  2691. if (status)
  2692. goto out;
  2693. renew_client(dp->dl_client);
  2694. if (filpp)
  2695. *filpp = find_readable_file(dp->dl_file);
  2696. BUG_ON(!*filpp);
  2697. } else { /* open or lock stateid */
  2698. stp = find_stateid(stateid, flags);
  2699. if (!stp)
  2700. goto out;
  2701. if (nfs4_check_fh(current_fh, stp))
  2702. goto out;
  2703. if (!stp->st_stateowner->so_confirmed)
  2704. goto out;
  2705. status = check_stateid_generation(stateid, &stp->st_stateid,
  2706. flags);
  2707. if (status)
  2708. goto out;
  2709. status = nfs4_check_openmode(stp, flags);
  2710. if (status)
  2711. goto out;
  2712. renew_client(stp->st_stateowner->so_client);
  2713. if (filpp) {
  2714. if (flags & RD_STATE)
  2715. *filpp = find_readable_file(stp->st_file);
  2716. else
  2717. *filpp = find_writeable_file(stp->st_file);
  2718. }
  2719. }
  2720. status = nfs_ok;
  2721. out:
  2722. return status;
  2723. }
  2724. static inline int
  2725. setlkflg (int type)
  2726. {
  2727. return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
  2728. RD_STATE : WR_STATE;
  2729. }
  2730. /*
  2731. * Checks for sequence id mutating operations.
  2732. */
  2733. static __be32
  2734. nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
  2735. stateid_t *stateid, int flags,
  2736. struct nfs4_stateowner **sopp,
  2737. struct nfs4_stateid **stpp, struct nfsd4_lock *lock)
  2738. {
  2739. struct nfs4_stateid *stp;
  2740. struct nfs4_stateowner *sop;
  2741. struct svc_fh *current_fh = &cstate->current_fh;
  2742. __be32 status;
  2743. dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
  2744. seqid, STATEID_VAL(stateid));
  2745. *stpp = NULL;
  2746. *sopp = NULL;
  2747. if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {
  2748. dprintk("NFSD: preprocess_seqid_op: magic stateid!\n");
  2749. return nfserr_bad_stateid;
  2750. }
  2751. if (STALE_STATEID(stateid))
  2752. return nfserr_stale_stateid;
  2753. if (nfsd4_has_session(cstate))
  2754. flags |= HAS_SESSION;
  2755. /*
  2756. * We return BAD_STATEID if filehandle doesn't match stateid,
  2757. * the confirmed flag is incorrecly set, or the generation
  2758. * number is incorrect.
  2759. */
  2760. stp = find_stateid(stateid, flags);
  2761. if (stp == NULL) {
  2762. /*
  2763. * Also, we should make sure this isn't just the result of
  2764. * a replayed close:
  2765. */
  2766. sop = search_close_lru(stateid->si_stateownerid, flags);
  2767. if (sop == NULL)
  2768. return nfserr_bad_stateid;
  2769. *sopp = sop;
  2770. goto check_replay;
  2771. }
  2772. *stpp = stp;
  2773. *sopp = sop = stp->st_stateowner;
  2774. if (lock) {
  2775. clientid_t *lockclid = &lock->v.new.clientid;
  2776. struct nfs4_client *clp = sop->so_client;
  2777. int lkflg = 0;
  2778. __be32 status;
  2779. lkflg = setlkflg(lock->lk_type);
  2780. if (lock->lk_is_new) {
  2781. if (!sop->so_is_open_owner)
  2782. return nfserr_bad_stateid;
  2783. if (!(flags & HAS_SESSION) &&
  2784. !same_clid(&clp->cl_clientid, lockclid))
  2785. return nfserr_bad_stateid;
  2786. /* stp is the open stateid */
  2787. status = nfs4_check_openmode(stp, lkflg);
  2788. if (status)
  2789. return status;
  2790. } else {
  2791. /* stp is the lock stateid */
  2792. status = nfs4_check_openmode(stp->st_openstp, lkflg);
  2793. if (status)
  2794. return status;
  2795. }
  2796. }
  2797. if (nfs4_check_fh(current_fh, stp)) {
  2798. dprintk("NFSD: preprocess_seqid_op: fh-stateid mismatch!\n");
  2799. return nfserr_bad_stateid;
  2800. }
  2801. /*
  2802. * We now validate the seqid and stateid generation numbers.
  2803. * For the moment, we ignore the possibility of
  2804. * generation number wraparound.
  2805. */
  2806. if (!(flags & HAS_SESSION) && seqid != sop->so_seqid)
  2807. goto check_replay;
  2808. if (sop->so_confirmed && flags & CONFIRM) {
  2809. dprintk("NFSD: preprocess_seqid_op: expected"
  2810. " unconfirmed stateowner!\n");
  2811. return nfserr_bad_stateid;
  2812. }
  2813. if (!sop->so_confirmed && !(flags & CONFIRM)) {
  2814. dprintk("NFSD: preprocess_seqid_op: stateowner not"
  2815. " confirmed yet!\n");
  2816. return nfserr_bad_stateid;
  2817. }
  2818. status = check_stateid_generation(stateid, &stp->st_stateid, flags);
  2819. if (status)
  2820. return status;
  2821. renew_client(sop->so_client);
  2822. return nfs_ok;
  2823. check_replay:
  2824. if (seqid == sop->so_seqid - 1) {
  2825. dprintk("NFSD: preprocess_seqid_op: retransmission?\n");
  2826. /* indicate replay to calling function */
  2827. return nfserr_replay_me;
  2828. }
  2829. dprintk("NFSD: preprocess_seqid_op: bad seqid (expected %d, got %d)\n",
  2830. sop->so_seqid, seqid);
  2831. *sopp = NULL;
  2832. return nfserr_bad_seqid;
  2833. }
  2834. __be32
  2835. nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
  2836. struct nfsd4_open_confirm *oc)
  2837. {
  2838. __be32 status;
  2839. struct nfs4_stateowner *sop;
  2840. struct nfs4_stateid *stp;
  2841. dprintk("NFSD: nfsd4_open_confirm on file %.*s\n",
  2842. (int)cstate->current_fh.fh_dentry->d_name.len,
  2843. cstate->current_fh.fh_dentry->d_name.name);
  2844. status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
  2845. if (status)
  2846. return status;
  2847. nfs4_lock_state();
  2848. if ((status = nfs4_preprocess_seqid_op(cstate,
  2849. oc->oc_seqid, &oc->oc_req_stateid,
  2850. CONFIRM | OPEN_STATE,
  2851. &oc->oc_stateowner, &stp, NULL)))
  2852. goto out;
  2853. sop = oc->oc_stateowner;
  2854. sop->so_confirmed = 1;
  2855. update_stateid(&stp->st_stateid);
  2856. memcpy(&oc->oc_resp_stateid, &stp->st_stateid, sizeof(stateid_t));
  2857. dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
  2858. __func__, oc->oc_seqid, STATEID_VAL(&stp->st_stateid));
  2859. nfsd4_create_clid_dir(sop->so_client);
  2860. out:
  2861. if (oc->oc_stateowner) {
  2862. nfs4_get_stateowner(oc->oc_stateowner);
  2863. cstate->replay_owner = oc->oc_stateowner;
  2864. }
  2865. nfs4_unlock_state();
  2866. return status;
  2867. }
  2868. /*
  2869. * unset all bits in union bitmap (bmap) that
  2870. * do not exist in share (from successful OPEN_DOWNGRADE)
  2871. */
  2872. static void
  2873. reset_union_bmap_access(unsigned long access, unsigned long *bmap)
  2874. {
  2875. int i;
  2876. for (i = 1; i < 4; i++) {
  2877. if ((i & access) != i)
  2878. __clear_bit(i, bmap);
  2879. }
  2880. }
  2881. static void
  2882. reset_union_bmap_deny(unsigned long deny, unsigned long *bmap)
  2883. {
  2884. int i;
  2885. for (i = 0; i < 4; i++) {
  2886. if ((i & deny) != i)
  2887. __clear_bit(i, bmap);
  2888. }
  2889. }
  2890. __be32
  2891. nfsd4_open_downgrade(struct svc_rqst *rqstp,
  2892. struct nfsd4_compound_state *cstate,
  2893. struct nfsd4_open_downgrade *od)
  2894. {
  2895. __be32 status;
  2896. struct nfs4_stateid *stp;
  2897. unsigned int share_access;
  2898. dprintk("NFSD: nfsd4_open_downgrade on file %.*s\n",
  2899. (int)cstate->current_fh.fh_dentry->d_name.len,
  2900. cstate->current_fh.fh_dentry->d_name.name);
  2901. if (!access_valid(od->od_share_access, cstate->minorversion)
  2902. || !deny_valid(od->od_share_deny))
  2903. return nfserr_inval;
  2904. nfs4_lock_state();
  2905. if ((status = nfs4_preprocess_seqid_op(cstate,
  2906. od->od_seqid,
  2907. &od->od_stateid,
  2908. OPEN_STATE,
  2909. &od->od_stateowner, &stp, NULL)))
  2910. goto out;
  2911. status = nfserr_inval;
  2912. if (!test_bit(od->od_share_access, &stp->st_access_bmap)) {
  2913. dprintk("NFSD:access not a subset current bitmap: 0x%lx, input access=%08x\n",
  2914. stp->st_access_bmap, od->od_share_access);
  2915. goto out;
  2916. }
  2917. if (!test_bit(od->od_share_deny, &stp->st_deny_bmap)) {
  2918. dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
  2919. stp->st_deny_bmap, od->od_share_deny);
  2920. goto out;
  2921. }
  2922. set_access(&share_access, stp->st_access_bmap);
  2923. nfs4_file_downgrade(stp->st_file, share_access & ~od->od_share_access);
  2924. reset_union_bmap_access(od->od_share_access, &stp->st_access_bmap);
  2925. reset_union_bmap_deny(od->od_share_deny, &stp->st_deny_bmap);
  2926. update_stateid(&stp->st_stateid);
  2927. memcpy(&od->od_stateid, &stp->st_stateid, sizeof(stateid_t));
  2928. status = nfs_ok;
  2929. out:
  2930. if (od->od_stateowner) {
  2931. nfs4_get_stateowner(od->od_stateowner);
  2932. cstate->replay_owner = od->od_stateowner;
  2933. }
  2934. nfs4_unlock_state();
  2935. return status;
  2936. }
  2937. /*
  2938. * nfs4_unlock_state() called after encode
  2939. */
  2940. __be32
  2941. nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
  2942. struct nfsd4_close *close)
  2943. {
  2944. __be32 status;
  2945. struct nfs4_stateid *stp;
  2946. dprintk("NFSD: nfsd4_close on file %.*s\n",
  2947. (int)cstate->current_fh.fh_dentry->d_name.len,
  2948. cstate->current_fh.fh_dentry->d_name.name);
  2949. nfs4_lock_state();
  2950. /* check close_lru for replay */
  2951. if ((status = nfs4_preprocess_seqid_op(cstate,
  2952. close->cl_seqid,
  2953. &close->cl_stateid,
  2954. OPEN_STATE | CLOSE_STATE,
  2955. &close->cl_stateowner, &stp, NULL)))
  2956. goto out;
  2957. status = nfs_ok;
  2958. update_stateid(&stp->st_stateid);
  2959. memcpy(&close->cl_stateid, &stp->st_stateid, sizeof(stateid_t));
  2960. /* release_stateid() calls nfsd_close() if needed */
  2961. release_open_stateid(stp);
  2962. /* place unused nfs4_stateowners on so_close_lru list to be
  2963. * released by the laundromat service after the lease period
  2964. * to enable us to handle CLOSE replay
  2965. */
  2966. if (list_empty(&close->cl_stateowner->so_stateids))
  2967. move_to_close_lru(close->cl_stateowner);
  2968. out:
  2969. if (close->cl_stateowner) {
  2970. nfs4_get_stateowner(close->cl_stateowner);
  2971. cstate->replay_owner = close->cl_stateowner;
  2972. }
  2973. nfs4_unlock_state();
  2974. return status;
  2975. }
  2976. __be32
  2977. nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
  2978. struct nfsd4_delegreturn *dr)
  2979. {
  2980. struct nfs4_delegation *dp;
  2981. stateid_t *stateid = &dr->dr_stateid;
  2982. struct inode *inode;
  2983. __be32 status;
  2984. int flags = 0;
  2985. if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
  2986. return status;
  2987. inode = cstate->current_fh.fh_dentry->d_inode;
  2988. if (nfsd4_has_session(cstate))
  2989. flags |= HAS_SESSION;
  2990. nfs4_lock_state();
  2991. status = nfserr_bad_stateid;
  2992. if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
  2993. goto out;
  2994. status = nfserr_stale_stateid;
  2995. if (STALE_STATEID(stateid))
  2996. goto out;
  2997. status = nfserr_bad_stateid;
  2998. if (!is_delegation_stateid(stateid))
  2999. goto out;
  3000. dp = find_delegation_stateid(inode, stateid);
  3001. if (!dp)
  3002. goto out;
  3003. status = check_stateid_generation(stateid, &dp->dl_stateid, flags);
  3004. if (status)
  3005. goto out;
  3006. renew_client(dp->dl_client);
  3007. unhash_delegation(dp);
  3008. out:
  3009. nfs4_unlock_state();
  3010. return status;
  3011. }
  3012. /*
  3013. * Lock owner state (byte-range locks)
  3014. */
  3015. #define LOFF_OVERFLOW(start, len) ((u64)(len) > ~(u64)(start))
  3016. #define LOCK_HASH_BITS 8
  3017. #define LOCK_HASH_SIZE (1 << LOCK_HASH_BITS)
  3018. #define LOCK_HASH_MASK (LOCK_HASH_SIZE - 1)
  3019. static inline u64
  3020. end_offset(u64 start, u64 len)
  3021. {
  3022. u64 end;
  3023. end = start + len;
  3024. return end >= start ? end: NFS4_MAX_UINT64;
  3025. }
  3026. /* last octet in a range */
  3027. static inline u64
  3028. last_byte_offset(u64 start, u64 len)
  3029. {
  3030. u64 end;
  3031. BUG_ON(!len);
  3032. end = start + len;
  3033. return end > start ? end - 1: NFS4_MAX_UINT64;
  3034. }
  3035. #define lockownerid_hashval(id) \
  3036. ((id) & LOCK_HASH_MASK)
  3037. static inline unsigned int
  3038. lock_ownerstr_hashval(struct inode *inode, u32 cl_id,
  3039. struct xdr_netobj *ownername)
  3040. {
  3041. return (file_hashval(inode) + cl_id
  3042. + opaque_hashval(ownername->data, ownername->len))
  3043. & LOCK_HASH_MASK;
  3044. }
  3045. static struct list_head lock_ownerid_hashtbl[LOCK_HASH_SIZE];
  3046. static struct list_head lock_ownerstr_hashtbl[LOCK_HASH_SIZE];
  3047. static struct list_head lockstateid_hashtbl[STATEID_HASH_SIZE];
  3048. static struct nfs4_stateid *
  3049. find_stateid(stateid_t *stid, int flags)
  3050. {
  3051. struct nfs4_stateid *local;
  3052. u32 st_id = stid->si_stateownerid;
  3053. u32 f_id = stid->si_fileid;
  3054. unsigned int hashval;
  3055. dprintk("NFSD: find_stateid flags 0x%x\n",flags);
  3056. if (flags & (LOCK_STATE | RD_STATE | WR_STATE)) {
  3057. hashval = stateid_hashval(st_id, f_id);
  3058. list_for_each_entry(local, &lockstateid_hashtbl[hashval], st_hash) {
  3059. if ((local->st_stateid.si_stateownerid == st_id) &&
  3060. (local->st_stateid.si_fileid == f_id))
  3061. return local;
  3062. }
  3063. }
  3064. if (flags & (OPEN_STATE | RD_STATE | WR_STATE)) {
  3065. hashval = stateid_hashval(st_id, f_id);
  3066. list_for_each_entry(local, &stateid_hashtbl[hashval], st_hash) {
  3067. if ((local->st_stateid.si_stateownerid == st_id) &&
  3068. (local->st_stateid.si_fileid == f_id))
  3069. return local;
  3070. }
  3071. }
  3072. return NULL;
  3073. }
  3074. static struct nfs4_delegation *
  3075. find_delegation_stateid(struct inode *ino, stateid_t *stid)
  3076. {
  3077. struct nfs4_file *fp;
  3078. struct nfs4_delegation *dl;
  3079. dprintk("NFSD: %s: stateid=" STATEID_FMT "\n", __func__,
  3080. STATEID_VAL(stid));
  3081. fp = find_file(ino);
  3082. if (!fp)
  3083. return NULL;
  3084. dl = find_delegation_file(fp, stid);
  3085. put_nfs4_file(fp);
  3086. return dl;
  3087. }
  3088. /*
  3089. * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
  3090. * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
  3091. * byte, because of sign extension problems. Since NFSv4 calls for 64-bit
  3092. * locking, this prevents us from being completely protocol-compliant. The
  3093. * real solution to this problem is to start using unsigned file offsets in
  3094. * the VFS, but this is a very deep change!
  3095. */
  3096. static inline void
  3097. nfs4_transform_lock_offset(struct file_lock *lock)
  3098. {
  3099. if (lock->fl_start < 0)
  3100. lock->fl_start = OFFSET_MAX;
  3101. if (lock->fl_end < 0)
  3102. lock->fl_end = OFFSET_MAX;
  3103. }
  3104. /* Hack!: For now, we're defining this just so we can use a pointer to it
  3105. * as a unique cookie to identify our (NFSv4's) posix locks. */
  3106. static const struct lock_manager_operations nfsd_posix_mng_ops = {
  3107. };
  3108. static inline void
  3109. nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
  3110. {
  3111. struct nfs4_stateowner *sop;
  3112. if (fl->fl_lmops == &nfsd_posix_mng_ops) {
  3113. sop = (struct nfs4_stateowner *) fl->fl_owner;
  3114. kref_get(&sop->so_ref);
  3115. deny->ld_sop = sop;
  3116. deny->ld_clientid = sop->so_client->cl_clientid;
  3117. } else {
  3118. deny->ld_sop = NULL;
  3119. deny->ld_clientid.cl_boot = 0;
  3120. deny->ld_clientid.cl_id = 0;
  3121. }
  3122. deny->ld_start = fl->fl_start;
  3123. deny->ld_length = NFS4_MAX_UINT64;
  3124. if (fl->fl_end != NFS4_MAX_UINT64)
  3125. deny->ld_length = fl->fl_end - fl->fl_start + 1;
  3126. deny->ld_type = NFS4_READ_LT;
  3127. if (fl->fl_type != F_RDLCK)
  3128. deny->ld_type = NFS4_WRITE_LT;
  3129. }
  3130. static struct nfs4_stateowner *
  3131. find_lockstateowner_str(struct inode *inode, clientid_t *clid,
  3132. struct xdr_netobj *owner)
  3133. {
  3134. unsigned int hashval = lock_ownerstr_hashval(inode, clid->cl_id, owner);
  3135. struct nfs4_stateowner *op;
  3136. list_for_each_entry(op, &lock_ownerstr_hashtbl[hashval], so_strhash) {
  3137. if (same_owner_str(op, owner, clid))
  3138. return op;
  3139. }
  3140. return NULL;
  3141. }
  3142. /*
  3143. * Alloc a lock owner structure.
  3144. * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has
  3145. * occured.
  3146. *
  3147. * strhashval = lock_ownerstr_hashval
  3148. */
  3149. static struct nfs4_stateowner *
  3150. alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfs4_stateid *open_stp, struct nfsd4_lock *lock) {
  3151. struct nfs4_stateowner *sop;
  3152. struct nfs4_replay *rp;
  3153. unsigned int idhashval;
  3154. if (!(sop = alloc_stateowner(&lock->lk_new_owner)))
  3155. return NULL;
  3156. idhashval = lockownerid_hashval(current_ownerid);
  3157. INIT_LIST_HEAD(&sop->so_idhash);
  3158. INIT_LIST_HEAD(&sop->so_strhash);
  3159. INIT_LIST_HEAD(&sop->so_perclient);
  3160. INIT_LIST_HEAD(&sop->so_stateids);
  3161. INIT_LIST_HEAD(&sop->so_perstateid);
  3162. INIT_LIST_HEAD(&sop->so_close_lru); /* not used */
  3163. sop->so_time = 0;
  3164. list_add(&sop->so_idhash, &lock_ownerid_hashtbl[idhashval]);
  3165. list_add(&sop->so_strhash, &lock_ownerstr_hashtbl[strhashval]);
  3166. list_add(&sop->so_perstateid, &open_stp->st_lockowners);
  3167. sop->so_is_open_owner = 0;
  3168. sop->so_id = current_ownerid++;
  3169. sop->so_client = clp;
  3170. /* It is the openowner seqid that will be incremented in encode in the
  3171. * case of new lockowners; so increment the lock seqid manually: */
  3172. sop->so_seqid = lock->lk_new_lock_seqid + 1;
  3173. sop->so_confirmed = 1;
  3174. rp = &sop->so_replay;
  3175. rp->rp_status = nfserr_serverfault;
  3176. rp->rp_buflen = 0;
  3177. rp->rp_buf = rp->rp_ibuf;
  3178. return sop;
  3179. }
  3180. static struct nfs4_stateid *
  3181. alloc_init_lock_stateid(struct nfs4_stateowner *sop, struct nfs4_file *fp, struct nfs4_stateid *open_stp)
  3182. {
  3183. struct nfs4_stateid *stp;
  3184. unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);
  3185. stp = nfs4_alloc_stateid();
  3186. if (stp == NULL)
  3187. goto out;
  3188. INIT_LIST_HEAD(&stp->st_hash);
  3189. INIT_LIST_HEAD(&stp->st_perfile);
  3190. INIT_LIST_HEAD(&stp->st_perstateowner);
  3191. INIT_LIST_HEAD(&stp->st_lockowners); /* not used */
  3192. list_add(&stp->st_hash, &lockstateid_hashtbl[hashval]);
  3193. list_add(&stp->st_perfile, &fp->fi_stateids);
  3194. list_add(&stp->st_perstateowner, &sop->so_stateids);
  3195. stp->st_stateowner = sop;
  3196. get_nfs4_file(fp);
  3197. stp->st_file = fp;
  3198. stp->st_stateid.si_boot = boot_time;
  3199. stp->st_stateid.si_stateownerid = sop->so_id;
  3200. stp->st_stateid.si_fileid = fp->fi_id;
  3201. stp->st_stateid.si_generation = 0;
  3202. stp->st_deny_bmap = open_stp->st_deny_bmap;
  3203. stp->st_openstp = open_stp;
  3204. out:
  3205. return stp;
  3206. }
  3207. static int
  3208. check_lock_length(u64 offset, u64 length)
  3209. {
  3210. return ((length == 0) || ((length != NFS4_MAX_UINT64) &&
  3211. LOFF_OVERFLOW(offset, length)));
  3212. }
  3213. /*
  3214. * LOCK operation
  3215. */
  3216. __be32
  3217. nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
  3218. struct nfsd4_lock *lock)
  3219. {
  3220. struct nfs4_stateowner *open_sop = NULL;
  3221. struct nfs4_stateowner *lock_sop = NULL;
  3222. struct nfs4_stateid *lock_stp;
  3223. struct nfs4_file *fp;
  3224. struct file *filp = NULL;
  3225. struct file_lock file_lock;
  3226. struct file_lock conflock;
  3227. __be32 status = 0;
  3228. unsigned int strhashval;
  3229. unsigned int cmd;
  3230. int err;
  3231. dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
  3232. (long long) lock->lk_offset,
  3233. (long long) lock->lk_length);
  3234. if (check_lock_length(lock->lk_offset, lock->lk_length))
  3235. return nfserr_inval;
  3236. if ((status = fh_verify(rqstp, &cstate->current_fh,
  3237. S_IFREG, NFSD_MAY_LOCK))) {
  3238. dprintk("NFSD: nfsd4_lock: permission denied!\n");
  3239. return status;
  3240. }
  3241. nfs4_lock_state();
  3242. if (lock->lk_is_new) {
  3243. /*
  3244. * Client indicates that this is a new lockowner.
  3245. * Use open owner and open stateid to create lock owner and
  3246. * lock stateid.
  3247. */
  3248. struct nfs4_stateid *open_stp = NULL;
  3249. status = nfserr_stale_clientid;
  3250. if (!nfsd4_has_session(cstate) &&
  3251. STALE_CLIENTID(&lock->lk_new_clientid))
  3252. goto out;
  3253. /* validate and update open stateid and open seqid */
  3254. status = nfs4_preprocess_seqid_op(cstate,
  3255. lock->lk_new_open_seqid,
  3256. &lock->lk_new_open_stateid,
  3257. OPEN_STATE,
  3258. &lock->lk_replay_owner, &open_stp,
  3259. lock);
  3260. if (status)
  3261. goto out;
  3262. open_sop = lock->lk_replay_owner;
  3263. /* create lockowner and lock stateid */
  3264. fp = open_stp->st_file;
  3265. strhashval = lock_ownerstr_hashval(fp->fi_inode,
  3266. open_sop->so_client->cl_clientid.cl_id,
  3267. &lock->v.new.owner);
  3268. /* XXX: Do we need to check for duplicate stateowners on
  3269. * the same file, or should they just be allowed (and
  3270. * create new stateids)? */
  3271. status = nfserr_resource;
  3272. lock_sop = alloc_init_lock_stateowner(strhashval,
  3273. open_sop->so_client, open_stp, lock);
  3274. if (lock_sop == NULL)
  3275. goto out;
  3276. lock_stp = alloc_init_lock_stateid(lock_sop, fp, open_stp);
  3277. if (lock_stp == NULL)
  3278. goto out;
  3279. } else {
  3280. /* lock (lock owner + lock stateid) already exists */
  3281. status = nfs4_preprocess_seqid_op(cstate,
  3282. lock->lk_old_lock_seqid,
  3283. &lock->lk_old_lock_stateid,
  3284. LOCK_STATE,
  3285. &lock->lk_replay_owner, &lock_stp, lock);
  3286. if (status)
  3287. goto out;
  3288. lock_sop = lock->lk_replay_owner;
  3289. fp = lock_stp->st_file;
  3290. }
  3291. /* lock->lk_replay_owner and lock_stp have been created or found */
  3292. status = nfserr_grace;
  3293. if (locks_in_grace() && !lock->lk_reclaim)
  3294. goto out;
  3295. status = nfserr_no_grace;
  3296. if (!locks_in_grace() && lock->lk_reclaim)
  3297. goto out;
  3298. locks_init_lock(&file_lock);
  3299. switch (lock->lk_type) {
  3300. case NFS4_READ_LT:
  3301. case NFS4_READW_LT:
  3302. if (find_readable_file(lock_stp->st_file)) {
  3303. nfs4_get_vfs_file(rqstp, fp, &cstate->current_fh, NFS4_SHARE_ACCESS_READ);
  3304. filp = find_readable_file(lock_stp->st_file);
  3305. }
  3306. file_lock.fl_type = F_RDLCK;
  3307. cmd = F_SETLK;
  3308. break;
  3309. case NFS4_WRITE_LT:
  3310. case NFS4_WRITEW_LT:
  3311. if (find_writeable_file(lock_stp->st_file)) {
  3312. nfs4_get_vfs_file(rqstp, fp, &cstate->current_fh, NFS4_SHARE_ACCESS_WRITE);
  3313. filp = find_writeable_file(lock_stp->st_file);
  3314. }
  3315. file_lock.fl_type = F_WRLCK;
  3316. cmd = F_SETLK;
  3317. break;
  3318. default:
  3319. status = nfserr_inval;
  3320. goto out;
  3321. }
  3322. if (!filp) {
  3323. status = nfserr_openmode;
  3324. goto out;
  3325. }
  3326. file_lock.fl_owner = (fl_owner_t)lock_sop;
  3327. file_lock.fl_pid = current->tgid;
  3328. file_lock.fl_file = filp;
  3329. file_lock.fl_flags = FL_POSIX;
  3330. file_lock.fl_lmops = &nfsd_posix_mng_ops;
  3331. file_lock.fl_start = lock->lk_offset;
  3332. file_lock.fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
  3333. nfs4_transform_lock_offset(&file_lock);
  3334. /*
  3335. * Try to lock the file in the VFS.
  3336. * Note: locks.c uses the BKL to protect the inode's lock list.
  3337. */
  3338. err = vfs_lock_file(filp, cmd, &file_lock, &conflock);
  3339. switch (-err) {
  3340. case 0: /* success! */
  3341. update_stateid(&lock_stp->st_stateid);
  3342. memcpy(&lock->lk_resp_stateid, &lock_stp->st_stateid,
  3343. sizeof(stateid_t));
  3344. status = 0;
  3345. break;
  3346. case (EAGAIN): /* conflock holds conflicting lock */
  3347. status = nfserr_denied;
  3348. dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
  3349. nfs4_set_lock_denied(&conflock, &lock->lk_denied);
  3350. break;
  3351. case (EDEADLK):
  3352. status = nfserr_deadlock;
  3353. break;
  3354. default:
  3355. dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
  3356. status = nfserr_resource;
  3357. break;
  3358. }
  3359. out:
  3360. if (status && lock->lk_is_new && lock_sop)
  3361. release_lockowner(lock_sop);
  3362. if (lock->lk_replay_owner) {
  3363. nfs4_get_stateowner(lock->lk_replay_owner);
  3364. cstate->replay_owner = lock->lk_replay_owner;
  3365. }
  3366. nfs4_unlock_state();
  3367. return status;
  3368. }
  3369. /*
  3370. * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
  3371. * so we do a temporary open here just to get an open file to pass to
  3372. * vfs_test_lock. (Arguably perhaps test_lock should be done with an
  3373. * inode operation.)
  3374. */
  3375. static int nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
  3376. {
  3377. struct file *file;
  3378. int err;
  3379. err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
  3380. if (err)
  3381. return err;
  3382. err = vfs_test_lock(file, lock);
  3383. nfsd_close(file);
  3384. return err;
  3385. }
  3386. /*
  3387. * LOCKT operation
  3388. */
  3389. __be32
  3390. nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
  3391. struct nfsd4_lockt *lockt)
  3392. {
  3393. struct inode *inode;
  3394. struct file_lock file_lock;
  3395. int error;
  3396. __be32 status;
  3397. if (locks_in_grace())
  3398. return nfserr_grace;
  3399. if (check_lock_length(lockt->lt_offset, lockt->lt_length))
  3400. return nfserr_inval;
  3401. lockt->lt_stateowner = NULL;
  3402. nfs4_lock_state();
  3403. status = nfserr_stale_clientid;
  3404. if (!nfsd4_has_session(cstate) && STALE_CLIENTID(&lockt->lt_clientid))
  3405. goto out;
  3406. if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0))) {
  3407. dprintk("NFSD: nfsd4_lockt: fh_verify() failed!\n");
  3408. if (status == nfserr_symlink)
  3409. status = nfserr_inval;
  3410. goto out;
  3411. }
  3412. inode = cstate->current_fh.fh_dentry->d_inode;
  3413. locks_init_lock(&file_lock);
  3414. switch (lockt->lt_type) {
  3415. case NFS4_READ_LT:
  3416. case NFS4_READW_LT:
  3417. file_lock.fl_type = F_RDLCK;
  3418. break;
  3419. case NFS4_WRITE_LT:
  3420. case NFS4_WRITEW_LT:
  3421. file_lock.fl_type = F_WRLCK;
  3422. break;
  3423. default:
  3424. dprintk("NFSD: nfs4_lockt: bad lock type!\n");
  3425. status = nfserr_inval;
  3426. goto out;
  3427. }
  3428. lockt->lt_stateowner = find_lockstateowner_str(inode,
  3429. &lockt->lt_clientid, &lockt->lt_owner);
  3430. if (lockt->lt_stateowner)
  3431. file_lock.fl_owner = (fl_owner_t)lockt->lt_stateowner;
  3432. file_lock.fl_pid = current->tgid;
  3433. file_lock.fl_flags = FL_POSIX;
  3434. file_lock.fl_start = lockt->lt_offset;
  3435. file_lock.fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
  3436. nfs4_transform_lock_offset(&file_lock);
  3437. status = nfs_ok;
  3438. error = nfsd_test_lock(rqstp, &cstate->current_fh, &file_lock);
  3439. if (error) {
  3440. status = nfserrno(error);
  3441. goto out;
  3442. }
  3443. if (file_lock.fl_type != F_UNLCK) {
  3444. status = nfserr_denied;
  3445. nfs4_set_lock_denied(&file_lock, &lockt->lt_denied);
  3446. }
  3447. out:
  3448. nfs4_unlock_state();
  3449. return status;
  3450. }
  3451. __be32
  3452. nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
  3453. struct nfsd4_locku *locku)
  3454. {
  3455. struct nfs4_stateid *stp;
  3456. struct file *filp = NULL;
  3457. struct file_lock file_lock;
  3458. __be32 status;
  3459. int err;
  3460. dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
  3461. (long long) locku->lu_offset,
  3462. (long long) locku->lu_length);
  3463. if (check_lock_length(locku->lu_offset, locku->lu_length))
  3464. return nfserr_inval;
  3465. nfs4_lock_state();
  3466. if ((status = nfs4_preprocess_seqid_op(cstate,
  3467. locku->lu_seqid,
  3468. &locku->lu_stateid,
  3469. LOCK_STATE,
  3470. &locku->lu_stateowner, &stp, NULL)))
  3471. goto out;
  3472. filp = find_any_file(stp->st_file);
  3473. if (!filp) {
  3474. status = nfserr_lock_range;
  3475. goto out;
  3476. }
  3477. BUG_ON(!filp);
  3478. locks_init_lock(&file_lock);
  3479. file_lock.fl_type = F_UNLCK;
  3480. file_lock.fl_owner = (fl_owner_t) locku->lu_stateowner;
  3481. file_lock.fl_pid = current->tgid;
  3482. file_lock.fl_file = filp;
  3483. file_lock.fl_flags = FL_POSIX;
  3484. file_lock.fl_lmops = &nfsd_posix_mng_ops;
  3485. file_lock.fl_start = locku->lu_offset;
  3486. file_lock.fl_end = last_byte_offset(locku->lu_offset, locku->lu_length);
  3487. nfs4_transform_lock_offset(&file_lock);
  3488. /*
  3489. * Try to unlock the file in the VFS.
  3490. */
  3491. err = vfs_lock_file(filp, F_SETLK, &file_lock, NULL);
  3492. if (err) {
  3493. dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
  3494. goto out_nfserr;
  3495. }
  3496. /*
  3497. * OK, unlock succeeded; the only thing left to do is update the stateid.
  3498. */
  3499. update_stateid(&stp->st_stateid);
  3500. memcpy(&locku->lu_stateid, &stp->st_stateid, sizeof(stateid_t));
  3501. out:
  3502. if (locku->lu_stateowner) {
  3503. nfs4_get_stateowner(locku->lu_stateowner);
  3504. cstate->replay_owner = locku->lu_stateowner;
  3505. }
  3506. nfs4_unlock_state();
  3507. return status;
  3508. out_nfserr:
  3509. status = nfserrno(err);
  3510. goto out;
  3511. }
  3512. /*
  3513. * returns
  3514. * 1: locks held by lockowner
  3515. * 0: no locks held by lockowner
  3516. */
  3517. static int
  3518. check_for_locks(struct nfs4_file *filp, struct nfs4_stateowner *lowner)
  3519. {
  3520. struct file_lock **flpp;
  3521. struct inode *inode = filp->fi_inode;
  3522. int status = 0;
  3523. lock_kernel();
  3524. for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
  3525. if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
  3526. status = 1;
  3527. goto out;
  3528. }
  3529. }
  3530. out:
  3531. unlock_kernel();
  3532. return status;
  3533. }
  3534. __be32
  3535. nfsd4_release_lockowner(struct svc_rqst *rqstp,
  3536. struct nfsd4_compound_state *cstate,
  3537. struct nfsd4_release_lockowner *rlockowner)
  3538. {
  3539. clientid_t *clid = &rlockowner->rl_clientid;
  3540. struct nfs4_stateowner *sop;
  3541. struct nfs4_stateid *stp;
  3542. struct xdr_netobj *owner = &rlockowner->rl_owner;
  3543. struct list_head matches;
  3544. int i;
  3545. __be32 status;
  3546. dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
  3547. clid->cl_boot, clid->cl_id);
  3548. /* XXX check for lease expiration */
  3549. status = nfserr_stale_clientid;
  3550. if (STALE_CLIENTID(clid))
  3551. return status;
  3552. nfs4_lock_state();
  3553. status = nfserr_locks_held;
  3554. /* XXX: we're doing a linear search through all the lockowners.
  3555. * Yipes! For now we'll just hope clients aren't really using
  3556. * release_lockowner much, but eventually we have to fix these
  3557. * data structures. */
  3558. INIT_LIST_HEAD(&matches);
  3559. for (i = 0; i < LOCK_HASH_SIZE; i++) {
  3560. list_for_each_entry(sop, &lock_ownerid_hashtbl[i], so_idhash) {
  3561. if (!same_owner_str(sop, owner, clid))
  3562. continue;
  3563. list_for_each_entry(stp, &sop->so_stateids,
  3564. st_perstateowner) {
  3565. if (check_for_locks(stp->st_file, sop))
  3566. goto out;
  3567. /* Note: so_perclient unused for lockowners,
  3568. * so it's OK to fool with here. */
  3569. list_add(&sop->so_perclient, &matches);
  3570. }
  3571. }
  3572. }
  3573. /* Clients probably won't expect us to return with some (but not all)
  3574. * of the lockowner state released; so don't release any until all
  3575. * have been checked. */
  3576. status = nfs_ok;
  3577. while (!list_empty(&matches)) {
  3578. sop = list_entry(matches.next, struct nfs4_stateowner,
  3579. so_perclient);
  3580. /* unhash_stateowner deletes so_perclient only
  3581. * for openowners. */
  3582. list_del(&sop->so_perclient);
  3583. release_lockowner(sop);
  3584. }
  3585. out:
  3586. nfs4_unlock_state();
  3587. return status;
  3588. }
  3589. static inline struct nfs4_client_reclaim *
  3590. alloc_reclaim(void)
  3591. {
  3592. return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
  3593. }
  3594. int
  3595. nfs4_has_reclaimed_state(const char *name, bool use_exchange_id)
  3596. {
  3597. unsigned int strhashval = clientstr_hashval(name);
  3598. struct nfs4_client *clp;
  3599. clp = find_confirmed_client_by_str(name, strhashval, use_exchange_id);
  3600. return clp ? 1 : 0;
  3601. }
  3602. /*
  3603. * failure => all reset bets are off, nfserr_no_grace...
  3604. */
  3605. int
  3606. nfs4_client_to_reclaim(const char *name)
  3607. {
  3608. unsigned int strhashval;
  3609. struct nfs4_client_reclaim *crp = NULL;
  3610. dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
  3611. crp = alloc_reclaim();
  3612. if (!crp)
  3613. return 0;
  3614. strhashval = clientstr_hashval(name);
  3615. INIT_LIST_HEAD(&crp->cr_strhash);
  3616. list_add(&crp->cr_strhash, &reclaim_str_hashtbl[strhashval]);
  3617. memcpy(crp->cr_recdir, name, HEXDIR_LEN);
  3618. reclaim_str_hashtbl_size++;
  3619. return 1;
  3620. }
  3621. static void
  3622. nfs4_release_reclaim(void)
  3623. {
  3624. struct nfs4_client_reclaim *crp = NULL;
  3625. int i;
  3626. for (i = 0; i < CLIENT_HASH_SIZE; i++) {
  3627. while (!list_empty(&reclaim_str_hashtbl[i])) {
  3628. crp = list_entry(reclaim_str_hashtbl[i].next,
  3629. struct nfs4_client_reclaim, cr_strhash);
  3630. list_del(&crp->cr_strhash);
  3631. kfree(crp);
  3632. reclaim_str_hashtbl_size--;
  3633. }
  3634. }
  3635. BUG_ON(reclaim_str_hashtbl_size);
  3636. }
  3637. /*
  3638. * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
  3639. static struct nfs4_client_reclaim *
  3640. nfs4_find_reclaim_client(clientid_t *clid)
  3641. {
  3642. unsigned int strhashval;
  3643. struct nfs4_client *clp;
  3644. struct nfs4_client_reclaim *crp = NULL;
  3645. /* find clientid in conf_id_hashtbl */
  3646. clp = find_confirmed_client(clid);
  3647. if (clp == NULL)
  3648. return NULL;
  3649. dprintk("NFSD: nfs4_find_reclaim_client for %.*s with recdir %s\n",
  3650. clp->cl_name.len, clp->cl_name.data,
  3651. clp->cl_recdir);
  3652. /* find clp->cl_name in reclaim_str_hashtbl */
  3653. strhashval = clientstr_hashval(clp->cl_recdir);
  3654. list_for_each_entry(crp, &reclaim_str_hashtbl[strhashval], cr_strhash) {
  3655. if (same_name(crp->cr_recdir, clp->cl_recdir)) {
  3656. return crp;
  3657. }
  3658. }
  3659. return NULL;
  3660. }
  3661. /*
  3662. * Called from OPEN. Look for clientid in reclaim list.
  3663. */
  3664. __be32
  3665. nfs4_check_open_reclaim(clientid_t *clid)
  3666. {
  3667. return nfs4_find_reclaim_client(clid) ? nfs_ok : nfserr_reclaim_bad;
  3668. }
  3669. /* initialization to perform at module load time: */
  3670. int
  3671. nfs4_state_init(void)
  3672. {
  3673. int i, status;
  3674. status = nfsd4_init_slabs();
  3675. if (status)
  3676. return status;
  3677. for (i = 0; i < CLIENT_HASH_SIZE; i++) {
  3678. INIT_LIST_HEAD(&conf_id_hashtbl[i]);
  3679. INIT_LIST_HEAD(&conf_str_hashtbl[i]);
  3680. INIT_LIST_HEAD(&unconf_str_hashtbl[i]);
  3681. INIT_LIST_HEAD(&unconf_id_hashtbl[i]);
  3682. INIT_LIST_HEAD(&reclaim_str_hashtbl[i]);
  3683. }
  3684. for (i = 0; i < SESSION_HASH_SIZE; i++)
  3685. INIT_LIST_HEAD(&sessionid_hashtbl[i]);
  3686. for (i = 0; i < FILE_HASH_SIZE; i++) {
  3687. INIT_LIST_HEAD(&file_hashtbl[i]);
  3688. }
  3689. for (i = 0; i < OWNER_HASH_SIZE; i++) {
  3690. INIT_LIST_HEAD(&ownerstr_hashtbl[i]);
  3691. INIT_LIST_HEAD(&ownerid_hashtbl[i]);
  3692. }
  3693. for (i = 0; i < STATEID_HASH_SIZE; i++) {
  3694. INIT_LIST_HEAD(&stateid_hashtbl[i]);
  3695. INIT_LIST_HEAD(&lockstateid_hashtbl[i]);
  3696. }
  3697. for (i = 0; i < LOCK_HASH_SIZE; i++) {
  3698. INIT_LIST_HEAD(&lock_ownerid_hashtbl[i]);
  3699. INIT_LIST_HEAD(&lock_ownerstr_hashtbl[i]);
  3700. }
  3701. memset(&onestateid, ~0, sizeof(stateid_t));
  3702. INIT_LIST_HEAD(&close_lru);
  3703. INIT_LIST_HEAD(&client_lru);
  3704. INIT_LIST_HEAD(&del_recall_lru);
  3705. reclaim_str_hashtbl_size = 0;
  3706. return 0;
  3707. }
  3708. static void
  3709. nfsd4_load_reboot_recovery_data(void)
  3710. {
  3711. int status;
  3712. nfs4_lock_state();
  3713. nfsd4_init_recdir(user_recovery_dirname);
  3714. status = nfsd4_recdir_load();
  3715. nfs4_unlock_state();
  3716. if (status)
  3717. printk("NFSD: Failure reading reboot recovery data\n");
  3718. }
  3719. /*
  3720. * Since the lifetime of a delegation isn't limited to that of an open, a
  3721. * client may quite reasonably hang on to a delegation as long as it has
  3722. * the inode cached. This becomes an obvious problem the first time a
  3723. * client's inode cache approaches the size of the server's total memory.
  3724. *
  3725. * For now we avoid this problem by imposing a hard limit on the number
  3726. * of delegations, which varies according to the server's memory size.
  3727. */
  3728. static void
  3729. set_max_delegations(void)
  3730. {
  3731. /*
  3732. * Allow at most 4 delegations per megabyte of RAM. Quick
  3733. * estimates suggest that in the worst case (where every delegation
  3734. * is for a different inode), a delegation could take about 1.5K,
  3735. * giving a worst case usage of about 6% of memory.
  3736. */
  3737. max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
  3738. }
  3739. /* initialization to perform when the nfsd service is started: */
  3740. static int
  3741. __nfs4_state_start(void)
  3742. {
  3743. int ret;
  3744. boot_time = get_seconds();
  3745. locks_start_grace(&nfsd4_manager);
  3746. printk(KERN_INFO "NFSD: starting %ld-second grace period\n",
  3747. nfsd4_grace);
  3748. ret = set_callback_cred();
  3749. if (ret)
  3750. return -ENOMEM;
  3751. laundry_wq = create_singlethread_workqueue("nfsd4");
  3752. if (laundry_wq == NULL)
  3753. return -ENOMEM;
  3754. ret = nfsd4_create_callback_queue();
  3755. if (ret)
  3756. goto out_free_laundry;
  3757. queue_delayed_work(laundry_wq, &laundromat_work, nfsd4_grace * HZ);
  3758. set_max_delegations();
  3759. return 0;
  3760. out_free_laundry:
  3761. destroy_workqueue(laundry_wq);
  3762. return ret;
  3763. }
  3764. int
  3765. nfs4_state_start(void)
  3766. {
  3767. nfsd4_load_reboot_recovery_data();
  3768. return __nfs4_state_start();
  3769. }
  3770. static void
  3771. __nfs4_state_shutdown(void)
  3772. {
  3773. int i;
  3774. struct nfs4_client *clp = NULL;
  3775. struct nfs4_delegation *dp = NULL;
  3776. struct list_head *pos, *next, reaplist;
  3777. for (i = 0; i < CLIENT_HASH_SIZE; i++) {
  3778. while (!list_empty(&conf_id_hashtbl[i])) {
  3779. clp = list_entry(conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
  3780. expire_client(clp);
  3781. }
  3782. while (!list_empty(&unconf_str_hashtbl[i])) {
  3783. clp = list_entry(unconf_str_hashtbl[i].next, struct nfs4_client, cl_strhash);
  3784. expire_client(clp);
  3785. }
  3786. }
  3787. INIT_LIST_HEAD(&reaplist);
  3788. spin_lock(&recall_lock);
  3789. list_for_each_safe(pos, next, &del_recall_lru) {
  3790. dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
  3791. list_move(&dp->dl_recall_lru, &reaplist);
  3792. }
  3793. spin_unlock(&recall_lock);
  3794. list_for_each_safe(pos, next, &reaplist) {
  3795. dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
  3796. list_del_init(&dp->dl_recall_lru);
  3797. unhash_delegation(dp);
  3798. }
  3799. nfsd4_shutdown_recdir();
  3800. }
  3801. void
  3802. nfs4_state_shutdown(void)
  3803. {
  3804. cancel_rearming_delayed_workqueue(laundry_wq, &laundromat_work);
  3805. destroy_workqueue(laundry_wq);
  3806. locks_end_grace(&nfsd4_manager);
  3807. nfs4_lock_state();
  3808. nfs4_release_reclaim();
  3809. __nfs4_state_shutdown();
  3810. nfs4_unlock_state();
  3811. nfsd4_destroy_callback_queue();
  3812. }
  3813. /*
  3814. * user_recovery_dirname is protected by the nfsd_mutex since it's only
  3815. * accessed when nfsd is starting.
  3816. */
  3817. static void
  3818. nfs4_set_recdir(char *recdir)
  3819. {
  3820. strcpy(user_recovery_dirname, recdir);
  3821. }
  3822. /*
  3823. * Change the NFSv4 recovery directory to recdir.
  3824. */
  3825. int
  3826. nfs4_reset_recoverydir(char *recdir)
  3827. {
  3828. int status;
  3829. struct path path;
  3830. status = kern_path(recdir, LOOKUP_FOLLOW, &path);
  3831. if (status)
  3832. return status;
  3833. status = -ENOTDIR;
  3834. if (S_ISDIR(path.dentry->d_inode->i_mode)) {
  3835. nfs4_set_recdir(recdir);
  3836. status = 0;
  3837. }
  3838. path_put(&path);
  3839. return status;
  3840. }
  3841. char *
  3842. nfs4_recoverydir(void)
  3843. {
  3844. return user_recovery_dirname;
  3845. }