nfs4state.c 87 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323
  1. /*
  2. * linux/fs/nfsd/nfs4state.c
  3. *
  4. * Copyright (c) 2001 The Regents of the University of Michigan.
  5. * All rights reserved.
  6. *
  7. * Kendrick Smith <kmsmith@umich.edu>
  8. * Andy Adamson <kandros@umich.edu>
  9. *
  10. * Redistribution and use in source and binary forms, with or without
  11. * modification, are permitted provided that the following conditions
  12. * are met:
  13. *
  14. * 1. Redistributions of source code must retain the above copyright
  15. * notice, this list of conditions and the following disclaimer.
  16. * 2. Redistributions in binary form must reproduce the above copyright
  17. * notice, this list of conditions and the following disclaimer in the
  18. * documentation and/or other materials provided with the distribution.
  19. * 3. Neither the name of the University nor the names of its
  20. * contributors may be used to endorse or promote products derived
  21. * from this software without specific prior written permission.
  22. *
  23. * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  24. * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  25. * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  26. * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  28. * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29. * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  30. * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  31. * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  32. * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  33. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34. *
  35. */
  36. #include <linux/param.h>
  37. #include <linux/major.h>
  38. #include <linux/slab.h>
  39. #include <linux/sunrpc/svc.h>
  40. #include <linux/nfsd/nfsd.h>
  41. #include <linux/nfsd/cache.h>
  42. #include <linux/mount.h>
  43. #include <linux/workqueue.h>
  44. #include <linux/smp_lock.h>
  45. #include <linux/kthread.h>
  46. #include <linux/nfs4.h>
  47. #include <linux/nfsd/state.h>
  48. #include <linux/nfsd/xdr4.h>
  49. #include <linux/namei.h>
  50. #include <linux/mutex.h>
  51. #define NFSDDBG_FACILITY NFSDDBG_PROC
  52. /* Globals */
  53. static time_t lease_time = 90; /* default lease time */
  54. static time_t user_lease_time = 90;
  55. static time_t boot_time;
  56. static int in_grace = 1;
  57. static u32 current_clientid = 1;
  58. static u32 current_ownerid = 1;
  59. static u32 current_fileid = 1;
  60. static u32 current_delegid = 1;
  61. static u32 nfs4_init;
  62. static stateid_t zerostateid; /* bits all 0 */
  63. static stateid_t onestateid; /* bits all 1 */
  64. #define ZERO_STATEID(stateid) (!memcmp((stateid), &zerostateid, sizeof(stateid_t)))
  65. #define ONE_STATEID(stateid) (!memcmp((stateid), &onestateid, sizeof(stateid_t)))
  66. /* forward declarations */
  67. static struct nfs4_stateid * find_stateid(stateid_t *stid, int flags);
  68. static struct nfs4_delegation * find_delegation_stateid(struct inode *ino, stateid_t *stid);
  69. static void release_stateid_lockowners(struct nfs4_stateid *open_stp);
  70. static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery";
  71. static void nfs4_set_recdir(char *recdir);
  72. /* Locking:
  73. *
  74. * client_mutex:
  75. * protects clientid_hashtbl[], clientstr_hashtbl[],
  76. * unconfstr_hashtbl[], uncofid_hashtbl[].
  77. */
  78. static DEFINE_MUTEX(client_mutex);
  79. static struct kmem_cache *stateowner_slab = NULL;
  80. static struct kmem_cache *file_slab = NULL;
  81. static struct kmem_cache *stateid_slab = NULL;
  82. static struct kmem_cache *deleg_slab = NULL;
  83. void
  84. nfs4_lock_state(void)
  85. {
  86. mutex_lock(&client_mutex);
  87. }
  88. void
  89. nfs4_unlock_state(void)
  90. {
  91. mutex_unlock(&client_mutex);
  92. }
  93. static inline u32
  94. opaque_hashval(const void *ptr, int nbytes)
  95. {
  96. unsigned char *cptr = (unsigned char *) ptr;
  97. u32 x = 0;
  98. while (nbytes--) {
  99. x *= 37;
  100. x += *cptr++;
  101. }
  102. return x;
  103. }
  104. /* forward declarations */
  105. static void release_stateowner(struct nfs4_stateowner *sop);
  106. static void release_stateid(struct nfs4_stateid *stp, int flags);
  107. /*
  108. * Delegation state
  109. */
  110. /* recall_lock protects the del_recall_lru */
  111. static DEFINE_SPINLOCK(recall_lock);
  112. static struct list_head del_recall_lru;
  113. static void
  114. free_nfs4_file(struct kref *kref)
  115. {
  116. struct nfs4_file *fp = container_of(kref, struct nfs4_file, fi_ref);
  117. list_del(&fp->fi_hash);
  118. iput(fp->fi_inode);
  119. kmem_cache_free(file_slab, fp);
  120. }
  121. static inline void
  122. put_nfs4_file(struct nfs4_file *fi)
  123. {
  124. kref_put(&fi->fi_ref, free_nfs4_file);
  125. }
  126. static inline void
  127. get_nfs4_file(struct nfs4_file *fi)
  128. {
  129. kref_get(&fi->fi_ref);
  130. }
  131. static int num_delegations;
  132. /*
  133. * Open owner state (share locks)
  134. */
  135. /* hash tables for nfs4_stateowner */
  136. #define OWNER_HASH_BITS 8
  137. #define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)
  138. #define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)
  139. #define ownerid_hashval(id) \
  140. ((id) & OWNER_HASH_MASK)
  141. #define ownerstr_hashval(clientid, ownername) \
  142. (((clientid) + opaque_hashval((ownername.data), (ownername.len))) & OWNER_HASH_MASK)
  143. static struct list_head ownerid_hashtbl[OWNER_HASH_SIZE];
  144. static struct list_head ownerstr_hashtbl[OWNER_HASH_SIZE];
  145. /* hash table for nfs4_file */
  146. #define FILE_HASH_BITS 8
  147. #define FILE_HASH_SIZE (1 << FILE_HASH_BITS)
  148. #define FILE_HASH_MASK (FILE_HASH_SIZE - 1)
  149. /* hash table for (open)nfs4_stateid */
  150. #define STATEID_HASH_BITS 10
  151. #define STATEID_HASH_SIZE (1 << STATEID_HASH_BITS)
  152. #define STATEID_HASH_MASK (STATEID_HASH_SIZE - 1)
  153. #define file_hashval(x) \
  154. hash_ptr(x, FILE_HASH_BITS)
  155. #define stateid_hashval(owner_id, file_id) \
  156. (((owner_id) + (file_id)) & STATEID_HASH_MASK)
  157. static struct list_head file_hashtbl[FILE_HASH_SIZE];
  158. static struct list_head stateid_hashtbl[STATEID_HASH_SIZE];
  159. static struct nfs4_delegation *
  160. alloc_init_deleg(struct nfs4_client *clp, struct nfs4_stateid *stp, struct svc_fh *current_fh, u32 type)
  161. {
  162. struct nfs4_delegation *dp;
  163. struct nfs4_file *fp = stp->st_file;
  164. struct nfs4_callback *cb = &stp->st_stateowner->so_client->cl_callback;
  165. dprintk("NFSD alloc_init_deleg\n");
  166. if (num_delegations > STATEID_HASH_SIZE * 4)
  167. return NULL;
  168. dp = kmem_cache_alloc(deleg_slab, GFP_KERNEL);
  169. if (dp == NULL)
  170. return dp;
  171. num_delegations++;
  172. INIT_LIST_HEAD(&dp->dl_perfile);
  173. INIT_LIST_HEAD(&dp->dl_perclnt);
  174. INIT_LIST_HEAD(&dp->dl_recall_lru);
  175. dp->dl_client = clp;
  176. get_nfs4_file(fp);
  177. dp->dl_file = fp;
  178. dp->dl_flock = NULL;
  179. get_file(stp->st_vfs_file);
  180. dp->dl_vfs_file = stp->st_vfs_file;
  181. dp->dl_type = type;
  182. dp->dl_recall.cbr_dp = NULL;
  183. dp->dl_recall.cbr_ident = cb->cb_ident;
  184. dp->dl_recall.cbr_trunc = 0;
  185. dp->dl_stateid.si_boot = boot_time;
  186. dp->dl_stateid.si_stateownerid = current_delegid++;
  187. dp->dl_stateid.si_fileid = 0;
  188. dp->dl_stateid.si_generation = 0;
  189. dp->dl_fhlen = current_fh->fh_handle.fh_size;
  190. memcpy(dp->dl_fhval, &current_fh->fh_handle.fh_base,
  191. current_fh->fh_handle.fh_size);
  192. dp->dl_time = 0;
  193. atomic_set(&dp->dl_count, 1);
  194. list_add(&dp->dl_perfile, &fp->fi_delegations);
  195. list_add(&dp->dl_perclnt, &clp->cl_delegations);
  196. return dp;
  197. }
  198. void
  199. nfs4_put_delegation(struct nfs4_delegation *dp)
  200. {
  201. if (atomic_dec_and_test(&dp->dl_count)) {
  202. dprintk("NFSD: freeing dp %p\n",dp);
  203. put_nfs4_file(dp->dl_file);
  204. kmem_cache_free(deleg_slab, dp);
  205. num_delegations--;
  206. }
  207. }
  208. /* Remove the associated file_lock first, then remove the delegation.
  209. * lease_modify() is called to remove the FS_LEASE file_lock from
  210. * the i_flock list, eventually calling nfsd's lock_manager
  211. * fl_release_callback.
  212. */
  213. static void
  214. nfs4_close_delegation(struct nfs4_delegation *dp)
  215. {
  216. struct file *filp = dp->dl_vfs_file;
  217. dprintk("NFSD: close_delegation dp %p\n",dp);
  218. dp->dl_vfs_file = NULL;
  219. /* The following nfsd_close may not actually close the file,
  220. * but we want to remove the lease in any case. */
  221. if (dp->dl_flock)
  222. setlease(filp, F_UNLCK, &dp->dl_flock);
  223. nfsd_close(filp);
  224. }
  225. /* Called under the state lock. */
  226. static void
  227. unhash_delegation(struct nfs4_delegation *dp)
  228. {
  229. list_del_init(&dp->dl_perfile);
  230. list_del_init(&dp->dl_perclnt);
  231. spin_lock(&recall_lock);
  232. list_del_init(&dp->dl_recall_lru);
  233. spin_unlock(&recall_lock);
  234. nfs4_close_delegation(dp);
  235. nfs4_put_delegation(dp);
  236. }
  237. /*
  238. * SETCLIENTID state
  239. */
  240. /* Hash tables for nfs4_clientid state */
  241. #define CLIENT_HASH_BITS 4
  242. #define CLIENT_HASH_SIZE (1 << CLIENT_HASH_BITS)
  243. #define CLIENT_HASH_MASK (CLIENT_HASH_SIZE - 1)
  244. #define clientid_hashval(id) \
  245. ((id) & CLIENT_HASH_MASK)
  246. #define clientstr_hashval(name) \
  247. (opaque_hashval((name), 8) & CLIENT_HASH_MASK)
  248. /*
  249. * reclaim_str_hashtbl[] holds known client info from previous reset/reboot
  250. * used in reboot/reset lease grace period processing
  251. *
  252. * conf_id_hashtbl[], and conf_str_hashtbl[] hold confirmed
  253. * setclientid_confirmed info.
  254. *
  255. * unconf_str_hastbl[] and unconf_id_hashtbl[] hold unconfirmed
  256. * setclientid info.
  257. *
  258. * client_lru holds client queue ordered by nfs4_client.cl_time
  259. * for lease renewal.
  260. *
  261. * close_lru holds (open) stateowner queue ordered by nfs4_stateowner.so_time
  262. * for last close replay.
  263. */
  264. static struct list_head reclaim_str_hashtbl[CLIENT_HASH_SIZE];
  265. static int reclaim_str_hashtbl_size = 0;
  266. static struct list_head conf_id_hashtbl[CLIENT_HASH_SIZE];
  267. static struct list_head conf_str_hashtbl[CLIENT_HASH_SIZE];
  268. static struct list_head unconf_str_hashtbl[CLIENT_HASH_SIZE];
  269. static struct list_head unconf_id_hashtbl[CLIENT_HASH_SIZE];
  270. static struct list_head client_lru;
  271. static struct list_head close_lru;
  272. static inline void
  273. renew_client(struct nfs4_client *clp)
  274. {
  275. /*
  276. * Move client to the end to the LRU list.
  277. */
  278. dprintk("renewing client (clientid %08x/%08x)\n",
  279. clp->cl_clientid.cl_boot,
  280. clp->cl_clientid.cl_id);
  281. list_move_tail(&clp->cl_lru, &client_lru);
  282. clp->cl_time = get_seconds();
  283. }
  284. /* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
  285. static int
  286. STALE_CLIENTID(clientid_t *clid)
  287. {
  288. if (clid->cl_boot == boot_time)
  289. return 0;
  290. dprintk("NFSD stale clientid (%08x/%08x)\n",
  291. clid->cl_boot, clid->cl_id);
  292. return 1;
  293. }
  294. /*
  295. * XXX Should we use a slab cache ?
  296. * This type of memory management is somewhat inefficient, but we use it
  297. * anyway since SETCLIENTID is not a common operation.
  298. */
  299. static inline struct nfs4_client *
  300. alloc_client(struct xdr_netobj name)
  301. {
  302. struct nfs4_client *clp;
  303. if ((clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL))!= NULL) {
  304. if ((clp->cl_name.data = kmalloc(name.len, GFP_KERNEL)) != NULL) {
  305. memcpy(clp->cl_name.data, name.data, name.len);
  306. clp->cl_name.len = name.len;
  307. }
  308. else {
  309. kfree(clp);
  310. clp = NULL;
  311. }
  312. }
  313. return clp;
  314. }
  315. static inline void
  316. free_client(struct nfs4_client *clp)
  317. {
  318. if (clp->cl_cred.cr_group_info)
  319. put_group_info(clp->cl_cred.cr_group_info);
  320. kfree(clp->cl_name.data);
  321. kfree(clp);
  322. }
  323. void
  324. put_nfs4_client(struct nfs4_client *clp)
  325. {
  326. if (atomic_dec_and_test(&clp->cl_count))
  327. free_client(clp);
  328. }
  329. static void
  330. shutdown_callback_client(struct nfs4_client *clp)
  331. {
  332. struct rpc_clnt *clnt = clp->cl_callback.cb_client;
  333. /* shutdown rpc client, ending any outstanding recall rpcs */
  334. if (clnt) {
  335. clp->cl_callback.cb_client = NULL;
  336. rpc_shutdown_client(clnt);
  337. rpciod_down();
  338. }
  339. }
  340. static void
  341. expire_client(struct nfs4_client *clp)
  342. {
  343. struct nfs4_stateowner *sop;
  344. struct nfs4_delegation *dp;
  345. struct list_head reaplist;
  346. dprintk("NFSD: expire_client cl_count %d\n",
  347. atomic_read(&clp->cl_count));
  348. shutdown_callback_client(clp);
  349. INIT_LIST_HEAD(&reaplist);
  350. spin_lock(&recall_lock);
  351. while (!list_empty(&clp->cl_delegations)) {
  352. dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
  353. dprintk("NFSD: expire client. dp %p, fp %p\n", dp,
  354. dp->dl_flock);
  355. list_del_init(&dp->dl_perclnt);
  356. list_move(&dp->dl_recall_lru, &reaplist);
  357. }
  358. spin_unlock(&recall_lock);
  359. while (!list_empty(&reaplist)) {
  360. dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
  361. list_del_init(&dp->dl_recall_lru);
  362. unhash_delegation(dp);
  363. }
  364. list_del(&clp->cl_idhash);
  365. list_del(&clp->cl_strhash);
  366. list_del(&clp->cl_lru);
  367. while (!list_empty(&clp->cl_openowners)) {
  368. sop = list_entry(clp->cl_openowners.next, struct nfs4_stateowner, so_perclient);
  369. release_stateowner(sop);
  370. }
  371. put_nfs4_client(clp);
  372. }
  373. static struct nfs4_client *
  374. create_client(struct xdr_netobj name, char *recdir) {
  375. struct nfs4_client *clp;
  376. if (!(clp = alloc_client(name)))
  377. goto out;
  378. memcpy(clp->cl_recdir, recdir, HEXDIR_LEN);
  379. atomic_set(&clp->cl_count, 1);
  380. atomic_set(&clp->cl_callback.cb_set, 0);
  381. INIT_LIST_HEAD(&clp->cl_idhash);
  382. INIT_LIST_HEAD(&clp->cl_strhash);
  383. INIT_LIST_HEAD(&clp->cl_openowners);
  384. INIT_LIST_HEAD(&clp->cl_delegations);
  385. INIT_LIST_HEAD(&clp->cl_lru);
  386. out:
  387. return clp;
  388. }
  389. static void
  390. copy_verf(struct nfs4_client *target, nfs4_verifier *source) {
  391. memcpy(target->cl_verifier.data, source->data, sizeof(target->cl_verifier.data));
  392. }
  393. static void
  394. copy_clid(struct nfs4_client *target, struct nfs4_client *source) {
  395. target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
  396. target->cl_clientid.cl_id = source->cl_clientid.cl_id;
  397. }
  398. static void
  399. copy_cred(struct svc_cred *target, struct svc_cred *source) {
  400. target->cr_uid = source->cr_uid;
  401. target->cr_gid = source->cr_gid;
  402. target->cr_group_info = source->cr_group_info;
  403. get_group_info(target->cr_group_info);
  404. }
  405. static inline int
  406. same_name(const char *n1, const char *n2) {
  407. return 0 == memcmp(n1, n2, HEXDIR_LEN);
  408. }
  409. static int
  410. cmp_verf(nfs4_verifier *v1, nfs4_verifier *v2) {
  411. return(!memcmp(v1->data,v2->data,sizeof(v1->data)));
  412. }
  413. static int
  414. cmp_clid(clientid_t * cl1, clientid_t * cl2) {
  415. return((cl1->cl_boot == cl2->cl_boot) &&
  416. (cl1->cl_id == cl2->cl_id));
  417. }
  418. /* XXX what about NGROUP */
  419. static int
  420. cmp_creds(struct svc_cred *cr1, struct svc_cred *cr2){
  421. return(cr1->cr_uid == cr2->cr_uid);
  422. }
  423. static void
  424. gen_clid(struct nfs4_client *clp) {
  425. clp->cl_clientid.cl_boot = boot_time;
  426. clp->cl_clientid.cl_id = current_clientid++;
  427. }
  428. static void
  429. gen_confirm(struct nfs4_client *clp) {
  430. struct timespec tv;
  431. u32 * p;
  432. tv = CURRENT_TIME;
  433. p = (u32 *)clp->cl_confirm.data;
  434. *p++ = tv.tv_sec;
  435. *p++ = tv.tv_nsec;
  436. }
  437. static int
  438. check_name(struct xdr_netobj name) {
  439. if (name.len == 0)
  440. return 0;
  441. if (name.len > NFS4_OPAQUE_LIMIT) {
  442. printk("NFSD: check_name: name too long(%d)!\n", name.len);
  443. return 0;
  444. }
  445. return 1;
  446. }
  447. static void
  448. add_to_unconfirmed(struct nfs4_client *clp, unsigned int strhashval)
  449. {
  450. unsigned int idhashval;
  451. list_add(&clp->cl_strhash, &unconf_str_hashtbl[strhashval]);
  452. idhashval = clientid_hashval(clp->cl_clientid.cl_id);
  453. list_add(&clp->cl_idhash, &unconf_id_hashtbl[idhashval]);
  454. list_add_tail(&clp->cl_lru, &client_lru);
  455. clp->cl_time = get_seconds();
  456. }
  457. static void
  458. move_to_confirmed(struct nfs4_client *clp)
  459. {
  460. unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
  461. unsigned int strhashval;
  462. dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
  463. list_del_init(&clp->cl_strhash);
  464. list_move(&clp->cl_idhash, &conf_id_hashtbl[idhashval]);
  465. strhashval = clientstr_hashval(clp->cl_recdir);
  466. list_add(&clp->cl_strhash, &conf_str_hashtbl[strhashval]);
  467. renew_client(clp);
  468. }
  469. static struct nfs4_client *
  470. find_confirmed_client(clientid_t *clid)
  471. {
  472. struct nfs4_client *clp;
  473. unsigned int idhashval = clientid_hashval(clid->cl_id);
  474. list_for_each_entry(clp, &conf_id_hashtbl[idhashval], cl_idhash) {
  475. if (cmp_clid(&clp->cl_clientid, clid))
  476. return clp;
  477. }
  478. return NULL;
  479. }
  480. static struct nfs4_client *
  481. find_unconfirmed_client(clientid_t *clid)
  482. {
  483. struct nfs4_client *clp;
  484. unsigned int idhashval = clientid_hashval(clid->cl_id);
  485. list_for_each_entry(clp, &unconf_id_hashtbl[idhashval], cl_idhash) {
  486. if (cmp_clid(&clp->cl_clientid, clid))
  487. return clp;
  488. }
  489. return NULL;
  490. }
  491. static struct nfs4_client *
  492. find_confirmed_client_by_str(const char *dname, unsigned int hashval)
  493. {
  494. struct nfs4_client *clp;
  495. list_for_each_entry(clp, &conf_str_hashtbl[hashval], cl_strhash) {
  496. if (same_name(clp->cl_recdir, dname))
  497. return clp;
  498. }
  499. return NULL;
  500. }
  501. static struct nfs4_client *
  502. find_unconfirmed_client_by_str(const char *dname, unsigned int hashval)
  503. {
  504. struct nfs4_client *clp;
  505. list_for_each_entry(clp, &unconf_str_hashtbl[hashval], cl_strhash) {
  506. if (same_name(clp->cl_recdir, dname))
  507. return clp;
  508. }
  509. return NULL;
  510. }
  511. /* a helper function for parse_callback */
  512. static int
  513. parse_octet(unsigned int *lenp, char **addrp)
  514. {
  515. unsigned int len = *lenp;
  516. char *p = *addrp;
  517. int n = -1;
  518. char c;
  519. for (;;) {
  520. if (!len)
  521. break;
  522. len--;
  523. c = *p++;
  524. if (c == '.')
  525. break;
  526. if ((c < '0') || (c > '9')) {
  527. n = -1;
  528. break;
  529. }
  530. if (n < 0)
  531. n = 0;
  532. n = (n * 10) + (c - '0');
  533. if (n > 255) {
  534. n = -1;
  535. break;
  536. }
  537. }
  538. *lenp = len;
  539. *addrp = p;
  540. return n;
  541. }
  542. /* parse and set the setclientid ipv4 callback address */
  543. static int
  544. parse_ipv4(unsigned int addr_len, char *addr_val, unsigned int *cbaddrp, unsigned short *cbportp)
  545. {
  546. int temp = 0;
  547. u32 cbaddr = 0;
  548. u16 cbport = 0;
  549. u32 addrlen = addr_len;
  550. char *addr = addr_val;
  551. int i, shift;
  552. /* ipaddress */
  553. shift = 24;
  554. for(i = 4; i > 0 ; i--) {
  555. if ((temp = parse_octet(&addrlen, &addr)) < 0) {
  556. return 0;
  557. }
  558. cbaddr |= (temp << shift);
  559. if (shift > 0)
  560. shift -= 8;
  561. }
  562. *cbaddrp = cbaddr;
  563. /* port */
  564. shift = 8;
  565. for(i = 2; i > 0 ; i--) {
  566. if ((temp = parse_octet(&addrlen, &addr)) < 0) {
  567. return 0;
  568. }
  569. cbport |= (temp << shift);
  570. if (shift > 0)
  571. shift -= 8;
  572. }
  573. *cbportp = cbport;
  574. return 1;
  575. }
  576. static void
  577. gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se)
  578. {
  579. struct nfs4_callback *cb = &clp->cl_callback;
  580. /* Currently, we only support tcp for the callback channel */
  581. if ((se->se_callback_netid_len != 3) || memcmp((char *)se->se_callback_netid_val, "tcp", 3))
  582. goto out_err;
  583. if ( !(parse_ipv4(se->se_callback_addr_len, se->se_callback_addr_val,
  584. &cb->cb_addr, &cb->cb_port)))
  585. goto out_err;
  586. cb->cb_prog = se->se_callback_prog;
  587. cb->cb_ident = se->se_callback_ident;
  588. return;
  589. out_err:
  590. dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
  591. "will not receive delegations\n",
  592. clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
  593. return;
  594. }
  595. /*
  596. * RFC 3010 has a complex implmentation description of processing a
  597. * SETCLIENTID request consisting of 5 bullets, labeled as
  598. * CASE0 - CASE4 below.
  599. *
  600. * NOTES:
  601. * callback information will be processed in a future patch
  602. *
  603. * an unconfirmed record is added when:
  604. * NORMAL (part of CASE 4): there is no confirmed nor unconfirmed record.
  605. * CASE 1: confirmed record found with matching name, principal,
  606. * verifier, and clientid.
  607. * CASE 2: confirmed record found with matching name, principal,
  608. * and there is no unconfirmed record with matching
  609. * name and principal
  610. *
  611. * an unconfirmed record is replaced when:
  612. * CASE 3: confirmed record found with matching name, principal,
  613. * and an unconfirmed record is found with matching
  614. * name, principal, and with clientid and
  615. * confirm that does not match the confirmed record.
  616. * CASE 4: there is no confirmed record with matching name and
  617. * principal. there is an unconfirmed record with
  618. * matching name, principal.
  619. *
  620. * an unconfirmed record is deleted when:
  621. * CASE 1: an unconfirmed record that matches input name, verifier,
  622. * and confirmed clientid.
  623. * CASE 4: any unconfirmed records with matching name and principal
  624. * that exist after an unconfirmed record has been replaced
  625. * as described above.
  626. *
  627. */
  628. __be32
  629. nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
  630. struct nfsd4_setclientid *setclid)
  631. {
  632. struct sockaddr_in *sin = svc_addr_in(rqstp);
  633. struct xdr_netobj clname = {
  634. .len = setclid->se_namelen,
  635. .data = setclid->se_name,
  636. };
  637. nfs4_verifier clverifier = setclid->se_verf;
  638. unsigned int strhashval;
  639. struct nfs4_client *conf, *unconf, *new;
  640. __be32 status;
  641. char dname[HEXDIR_LEN];
  642. if (!check_name(clname))
  643. return nfserr_inval;
  644. status = nfs4_make_rec_clidname(dname, &clname);
  645. if (status)
  646. return status;
  647. /*
  648. * XXX The Duplicate Request Cache (DRC) has been checked (??)
  649. * We get here on a DRC miss.
  650. */
  651. strhashval = clientstr_hashval(dname);
  652. nfs4_lock_state();
  653. conf = find_confirmed_client_by_str(dname, strhashval);
  654. if (conf) {
  655. /*
  656. * CASE 0:
  657. * clname match, confirmed, different principal
  658. * or different ip_address
  659. */
  660. status = nfserr_clid_inuse;
  661. if (!cmp_creds(&conf->cl_cred, &rqstp->rq_cred)
  662. || conf->cl_addr != sin->sin_addr.s_addr) {
  663. dprintk("NFSD: setclientid: string in use by client"
  664. "at %u.%u.%u.%u\n", NIPQUAD(conf->cl_addr));
  665. goto out;
  666. }
  667. }
  668. unconf = find_unconfirmed_client_by_str(dname, strhashval);
  669. status = nfserr_resource;
  670. if (!conf) {
  671. /*
  672. * CASE 4:
  673. * placed first, because it is the normal case.
  674. */
  675. if (unconf)
  676. expire_client(unconf);
  677. new = create_client(clname, dname);
  678. if (new == NULL)
  679. goto out;
  680. copy_verf(new, &clverifier);
  681. new->cl_addr = sin->sin_addr.s_addr;
  682. copy_cred(&new->cl_cred,&rqstp->rq_cred);
  683. gen_clid(new);
  684. gen_confirm(new);
  685. gen_callback(new, setclid);
  686. add_to_unconfirmed(new, strhashval);
  687. } else if (cmp_verf(&conf->cl_verifier, &clverifier)) {
  688. /*
  689. * CASE 1:
  690. * cl_name match, confirmed, principal match
  691. * verifier match: probable callback update
  692. *
  693. * remove any unconfirmed nfs4_client with
  694. * matching cl_name, cl_verifier, and cl_clientid
  695. *
  696. * create and insert an unconfirmed nfs4_client with same
  697. * cl_name, cl_verifier, and cl_clientid as existing
  698. * nfs4_client, but with the new callback info and a
  699. * new cl_confirm
  700. */
  701. if (unconf) {
  702. /* Note this is removing unconfirmed {*x***},
  703. * which is stronger than RFC recommended {vxc**}.
  704. * This has the advantage that there is at most
  705. * one {*x***} in either list at any time.
  706. */
  707. expire_client(unconf);
  708. }
  709. new = create_client(clname, dname);
  710. if (new == NULL)
  711. goto out;
  712. copy_verf(new,&conf->cl_verifier);
  713. new->cl_addr = sin->sin_addr.s_addr;
  714. copy_cred(&new->cl_cred,&rqstp->rq_cred);
  715. copy_clid(new, conf);
  716. gen_confirm(new);
  717. gen_callback(new, setclid);
  718. add_to_unconfirmed(new,strhashval);
  719. } else if (!unconf) {
  720. /*
  721. * CASE 2:
  722. * clname match, confirmed, principal match
  723. * verfier does not match
  724. * no unconfirmed. create a new unconfirmed nfs4_client
  725. * using input clverifier, clname, and callback info
  726. * and generate a new cl_clientid and cl_confirm.
  727. */
  728. new = create_client(clname, dname);
  729. if (new == NULL)
  730. goto out;
  731. copy_verf(new,&clverifier);
  732. new->cl_addr = sin->sin_addr.s_addr;
  733. copy_cred(&new->cl_cred,&rqstp->rq_cred);
  734. gen_clid(new);
  735. gen_confirm(new);
  736. gen_callback(new, setclid);
  737. add_to_unconfirmed(new, strhashval);
  738. } else if (!cmp_verf(&conf->cl_confirm, &unconf->cl_confirm)) {
  739. /*
  740. * CASE3:
  741. * confirmed found (name, principal match)
  742. * confirmed verifier does not match input clverifier
  743. *
  744. * unconfirmed found (name match)
  745. * confirmed->cl_confirm != unconfirmed->cl_confirm
  746. *
  747. * remove unconfirmed.
  748. *
  749. * create an unconfirmed nfs4_client
  750. * with same cl_name as existing confirmed nfs4_client,
  751. * but with new callback info, new cl_clientid,
  752. * new cl_verifier and a new cl_confirm
  753. */
  754. expire_client(unconf);
  755. new = create_client(clname, dname);
  756. if (new == NULL)
  757. goto out;
  758. copy_verf(new,&clverifier);
  759. new->cl_addr = sin->sin_addr.s_addr;
  760. copy_cred(&new->cl_cred,&rqstp->rq_cred);
  761. gen_clid(new);
  762. gen_confirm(new);
  763. gen_callback(new, setclid);
  764. add_to_unconfirmed(new, strhashval);
  765. } else {
  766. /* No cases hit !!! */
  767. status = nfserr_inval;
  768. goto out;
  769. }
  770. setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
  771. setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
  772. memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
  773. status = nfs_ok;
  774. out:
  775. nfs4_unlock_state();
  776. return status;
  777. }
  778. /*
  779. * RFC 3010 has a complex implmentation description of processing a
  780. * SETCLIENTID_CONFIRM request consisting of 4 bullets describing
  781. * processing on a DRC miss, labeled as CASE1 - CASE4 below.
  782. *
  783. * NOTE: callback information will be processed here in a future patch
  784. */
  785. __be32
  786. nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
  787. struct nfsd4_compound_state *cstate,
  788. struct nfsd4_setclientid_confirm *setclientid_confirm)
  789. {
  790. struct sockaddr_in *sin = svc_addr_in(rqstp);
  791. struct nfs4_client *conf, *unconf;
  792. nfs4_verifier confirm = setclientid_confirm->sc_confirm;
  793. clientid_t * clid = &setclientid_confirm->sc_clientid;
  794. __be32 status;
  795. if (STALE_CLIENTID(clid))
  796. return nfserr_stale_clientid;
  797. /*
  798. * XXX The Duplicate Request Cache (DRC) has been checked (??)
  799. * We get here on a DRC miss.
  800. */
  801. nfs4_lock_state();
  802. conf = find_confirmed_client(clid);
  803. unconf = find_unconfirmed_client(clid);
  804. status = nfserr_clid_inuse;
  805. if (conf && conf->cl_addr != sin->sin_addr.s_addr)
  806. goto out;
  807. if (unconf && unconf->cl_addr != sin->sin_addr.s_addr)
  808. goto out;
  809. if ((conf && unconf) &&
  810. (cmp_verf(&unconf->cl_confirm, &confirm)) &&
  811. (cmp_verf(&conf->cl_verifier, &unconf->cl_verifier)) &&
  812. (same_name(conf->cl_recdir,unconf->cl_recdir)) &&
  813. (!cmp_verf(&conf->cl_confirm, &unconf->cl_confirm))) {
  814. /* CASE 1:
  815. * unconf record that matches input clientid and input confirm.
  816. * conf record that matches input clientid.
  817. * conf and unconf records match names, verifiers
  818. */
  819. if (!cmp_creds(&conf->cl_cred, &unconf->cl_cred))
  820. status = nfserr_clid_inuse;
  821. else {
  822. /* XXX: We just turn off callbacks until we can handle
  823. * change request correctly. */
  824. atomic_set(&conf->cl_callback.cb_set, 0);
  825. gen_confirm(conf);
  826. nfsd4_remove_clid_dir(unconf);
  827. expire_client(unconf);
  828. status = nfs_ok;
  829. }
  830. } else if ((conf && !unconf) ||
  831. ((conf && unconf) &&
  832. (!cmp_verf(&conf->cl_verifier, &unconf->cl_verifier) ||
  833. !same_name(conf->cl_recdir, unconf->cl_recdir)))) {
  834. /* CASE 2:
  835. * conf record that matches input clientid.
  836. * if unconf record matches input clientid, then
  837. * unconf->cl_name or unconf->cl_verifier don't match the
  838. * conf record.
  839. */
  840. if (!cmp_creds(&conf->cl_cred,&rqstp->rq_cred))
  841. status = nfserr_clid_inuse;
  842. else
  843. status = nfs_ok;
  844. } else if (!conf && unconf
  845. && cmp_verf(&unconf->cl_confirm, &confirm)) {
  846. /* CASE 3:
  847. * conf record not found.
  848. * unconf record found.
  849. * unconf->cl_confirm matches input confirm
  850. */
  851. if (!cmp_creds(&unconf->cl_cred, &rqstp->rq_cred)) {
  852. status = nfserr_clid_inuse;
  853. } else {
  854. unsigned int hash =
  855. clientstr_hashval(unconf->cl_recdir);
  856. conf = find_confirmed_client_by_str(unconf->cl_recdir,
  857. hash);
  858. if (conf) {
  859. nfsd4_remove_clid_dir(conf);
  860. expire_client(conf);
  861. }
  862. move_to_confirmed(unconf);
  863. conf = unconf;
  864. status = nfs_ok;
  865. }
  866. } else if ((!conf || (conf && !cmp_verf(&conf->cl_confirm, &confirm)))
  867. && (!unconf || (unconf && !cmp_verf(&unconf->cl_confirm,
  868. &confirm)))) {
  869. /* CASE 4:
  870. * conf record not found, or if conf, conf->cl_confirm does not
  871. * match input confirm.
  872. * unconf record not found, or if unconf, unconf->cl_confirm
  873. * does not match input confirm.
  874. */
  875. status = nfserr_stale_clientid;
  876. } else {
  877. /* check that we have hit one of the cases...*/
  878. status = nfserr_clid_inuse;
  879. }
  880. out:
  881. if (!status)
  882. nfsd4_probe_callback(conf);
  883. nfs4_unlock_state();
  884. return status;
  885. }
  886. /* OPEN Share state helper functions */
  887. static inline struct nfs4_file *
  888. alloc_init_file(struct inode *ino)
  889. {
  890. struct nfs4_file *fp;
  891. unsigned int hashval = file_hashval(ino);
  892. fp = kmem_cache_alloc(file_slab, GFP_KERNEL);
  893. if (fp) {
  894. kref_init(&fp->fi_ref);
  895. INIT_LIST_HEAD(&fp->fi_hash);
  896. INIT_LIST_HEAD(&fp->fi_stateids);
  897. INIT_LIST_HEAD(&fp->fi_delegations);
  898. list_add(&fp->fi_hash, &file_hashtbl[hashval]);
  899. fp->fi_inode = igrab(ino);
  900. fp->fi_id = current_fileid++;
  901. return fp;
  902. }
  903. return NULL;
  904. }
  905. static void
  906. nfsd4_free_slab(struct kmem_cache **slab)
  907. {
  908. if (*slab == NULL)
  909. return;
  910. kmem_cache_destroy(*slab);
  911. *slab = NULL;
  912. }
  913. static void
  914. nfsd4_free_slabs(void)
  915. {
  916. nfsd4_free_slab(&stateowner_slab);
  917. nfsd4_free_slab(&file_slab);
  918. nfsd4_free_slab(&stateid_slab);
  919. nfsd4_free_slab(&deleg_slab);
  920. }
  921. static int
  922. nfsd4_init_slabs(void)
  923. {
  924. stateowner_slab = kmem_cache_create("nfsd4_stateowners",
  925. sizeof(struct nfs4_stateowner), 0, 0, NULL, NULL);
  926. if (stateowner_slab == NULL)
  927. goto out_nomem;
  928. file_slab = kmem_cache_create("nfsd4_files",
  929. sizeof(struct nfs4_file), 0, 0, NULL, NULL);
  930. if (file_slab == NULL)
  931. goto out_nomem;
  932. stateid_slab = kmem_cache_create("nfsd4_stateids",
  933. sizeof(struct nfs4_stateid), 0, 0, NULL, NULL);
  934. if (stateid_slab == NULL)
  935. goto out_nomem;
  936. deleg_slab = kmem_cache_create("nfsd4_delegations",
  937. sizeof(struct nfs4_delegation), 0, 0, NULL, NULL);
  938. if (deleg_slab == NULL)
  939. goto out_nomem;
  940. return 0;
  941. out_nomem:
  942. nfsd4_free_slabs();
  943. dprintk("nfsd4: out of memory while initializing nfsv4\n");
  944. return -ENOMEM;
  945. }
  946. void
  947. nfs4_free_stateowner(struct kref *kref)
  948. {
  949. struct nfs4_stateowner *sop =
  950. container_of(kref, struct nfs4_stateowner, so_ref);
  951. kfree(sop->so_owner.data);
  952. kmem_cache_free(stateowner_slab, sop);
  953. }
  954. static inline struct nfs4_stateowner *
  955. alloc_stateowner(struct xdr_netobj *owner)
  956. {
  957. struct nfs4_stateowner *sop;
  958. if ((sop = kmem_cache_alloc(stateowner_slab, GFP_KERNEL))) {
  959. if ((sop->so_owner.data = kmalloc(owner->len, GFP_KERNEL))) {
  960. memcpy(sop->so_owner.data, owner->data, owner->len);
  961. sop->so_owner.len = owner->len;
  962. kref_init(&sop->so_ref);
  963. return sop;
  964. }
  965. kmem_cache_free(stateowner_slab, sop);
  966. }
  967. return NULL;
  968. }
  969. static struct nfs4_stateowner *
  970. alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
  971. struct nfs4_stateowner *sop;
  972. struct nfs4_replay *rp;
  973. unsigned int idhashval;
  974. if (!(sop = alloc_stateowner(&open->op_owner)))
  975. return NULL;
  976. idhashval = ownerid_hashval(current_ownerid);
  977. INIT_LIST_HEAD(&sop->so_idhash);
  978. INIT_LIST_HEAD(&sop->so_strhash);
  979. INIT_LIST_HEAD(&sop->so_perclient);
  980. INIT_LIST_HEAD(&sop->so_stateids);
  981. INIT_LIST_HEAD(&sop->so_perstateid); /* not used */
  982. INIT_LIST_HEAD(&sop->so_close_lru);
  983. sop->so_time = 0;
  984. list_add(&sop->so_idhash, &ownerid_hashtbl[idhashval]);
  985. list_add(&sop->so_strhash, &ownerstr_hashtbl[strhashval]);
  986. list_add(&sop->so_perclient, &clp->cl_openowners);
  987. sop->so_is_open_owner = 1;
  988. sop->so_id = current_ownerid++;
  989. sop->so_client = clp;
  990. sop->so_seqid = open->op_seqid;
  991. sop->so_confirmed = 0;
  992. rp = &sop->so_replay;
  993. rp->rp_status = nfserr_serverfault;
  994. rp->rp_buflen = 0;
  995. rp->rp_buf = rp->rp_ibuf;
  996. return sop;
  997. }
  998. static void
  999. release_stateid_lockowners(struct nfs4_stateid *open_stp)
  1000. {
  1001. struct nfs4_stateowner *lock_sop;
  1002. while (!list_empty(&open_stp->st_lockowners)) {
  1003. lock_sop = list_entry(open_stp->st_lockowners.next,
  1004. struct nfs4_stateowner, so_perstateid);
  1005. /* list_del(&open_stp->st_lockowners); */
  1006. BUG_ON(lock_sop->so_is_open_owner);
  1007. release_stateowner(lock_sop);
  1008. }
  1009. }
  1010. static void
  1011. unhash_stateowner(struct nfs4_stateowner *sop)
  1012. {
  1013. struct nfs4_stateid *stp;
  1014. list_del(&sop->so_idhash);
  1015. list_del(&sop->so_strhash);
  1016. if (sop->so_is_open_owner)
  1017. list_del(&sop->so_perclient);
  1018. list_del(&sop->so_perstateid);
  1019. while (!list_empty(&sop->so_stateids)) {
  1020. stp = list_entry(sop->so_stateids.next,
  1021. struct nfs4_stateid, st_perstateowner);
  1022. if (sop->so_is_open_owner)
  1023. release_stateid(stp, OPEN_STATE);
  1024. else
  1025. release_stateid(stp, LOCK_STATE);
  1026. }
  1027. }
  1028. static void
  1029. release_stateowner(struct nfs4_stateowner *sop)
  1030. {
  1031. unhash_stateowner(sop);
  1032. list_del(&sop->so_close_lru);
  1033. nfs4_put_stateowner(sop);
  1034. }
  1035. static inline void
  1036. init_stateid(struct nfs4_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) {
  1037. struct nfs4_stateowner *sop = open->op_stateowner;
  1038. unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);
  1039. INIT_LIST_HEAD(&stp->st_hash);
  1040. INIT_LIST_HEAD(&stp->st_perstateowner);
  1041. INIT_LIST_HEAD(&stp->st_lockowners);
  1042. INIT_LIST_HEAD(&stp->st_perfile);
  1043. list_add(&stp->st_hash, &stateid_hashtbl[hashval]);
  1044. list_add(&stp->st_perstateowner, &sop->so_stateids);
  1045. list_add(&stp->st_perfile, &fp->fi_stateids);
  1046. stp->st_stateowner = sop;
  1047. get_nfs4_file(fp);
  1048. stp->st_file = fp;
  1049. stp->st_stateid.si_boot = boot_time;
  1050. stp->st_stateid.si_stateownerid = sop->so_id;
  1051. stp->st_stateid.si_fileid = fp->fi_id;
  1052. stp->st_stateid.si_generation = 0;
  1053. stp->st_access_bmap = 0;
  1054. stp->st_deny_bmap = 0;
  1055. __set_bit(open->op_share_access, &stp->st_access_bmap);
  1056. __set_bit(open->op_share_deny, &stp->st_deny_bmap);
  1057. stp->st_openstp = NULL;
  1058. }
  1059. static void
  1060. release_stateid(struct nfs4_stateid *stp, int flags)
  1061. {
  1062. struct file *filp = stp->st_vfs_file;
  1063. list_del(&stp->st_hash);
  1064. list_del(&stp->st_perfile);
  1065. list_del(&stp->st_perstateowner);
  1066. if (flags & OPEN_STATE) {
  1067. release_stateid_lockowners(stp);
  1068. stp->st_vfs_file = NULL;
  1069. nfsd_close(filp);
  1070. } else if (flags & LOCK_STATE)
  1071. locks_remove_posix(filp, (fl_owner_t) stp->st_stateowner);
  1072. put_nfs4_file(stp->st_file);
  1073. kmem_cache_free(stateid_slab, stp);
  1074. }
  1075. static void
  1076. move_to_close_lru(struct nfs4_stateowner *sop)
  1077. {
  1078. dprintk("NFSD: move_to_close_lru nfs4_stateowner %p\n", sop);
  1079. list_move_tail(&sop->so_close_lru, &close_lru);
  1080. sop->so_time = get_seconds();
  1081. }
  1082. static int
  1083. cmp_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner, clientid_t *clid) {
  1084. return ((sop->so_owner.len == owner->len) &&
  1085. !memcmp(sop->so_owner.data, owner->data, owner->len) &&
  1086. (sop->so_client->cl_clientid.cl_id == clid->cl_id));
  1087. }
  1088. static struct nfs4_stateowner *
  1089. find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open)
  1090. {
  1091. struct nfs4_stateowner *so = NULL;
  1092. list_for_each_entry(so, &ownerstr_hashtbl[hashval], so_strhash) {
  1093. if (cmp_owner_str(so, &open->op_owner, &open->op_clientid))
  1094. return so;
  1095. }
  1096. return NULL;
  1097. }
  1098. /* search file_hashtbl[] for file */
  1099. static struct nfs4_file *
  1100. find_file(struct inode *ino)
  1101. {
  1102. unsigned int hashval = file_hashval(ino);
  1103. struct nfs4_file *fp;
  1104. list_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
  1105. if (fp->fi_inode == ino) {
  1106. get_nfs4_file(fp);
  1107. return fp;
  1108. }
  1109. }
  1110. return NULL;
  1111. }
  1112. static int access_valid(u32 x)
  1113. {
  1114. return (x > 0 && x < 4);
  1115. }
  1116. static int deny_valid(u32 x)
  1117. {
  1118. return (x >= 0 && x < 5);
  1119. }
  1120. static void
  1121. set_access(unsigned int *access, unsigned long bmap) {
  1122. int i;
  1123. *access = 0;
  1124. for (i = 1; i < 4; i++) {
  1125. if (test_bit(i, &bmap))
  1126. *access |= i;
  1127. }
  1128. }
  1129. static void
  1130. set_deny(unsigned int *deny, unsigned long bmap) {
  1131. int i;
  1132. *deny = 0;
  1133. for (i = 0; i < 4; i++) {
  1134. if (test_bit(i, &bmap))
  1135. *deny |= i ;
  1136. }
  1137. }
  1138. static int
  1139. test_share(struct nfs4_stateid *stp, struct nfsd4_open *open) {
  1140. unsigned int access, deny;
  1141. set_access(&access, stp->st_access_bmap);
  1142. set_deny(&deny, stp->st_deny_bmap);
  1143. if ((access & open->op_share_deny) || (deny & open->op_share_access))
  1144. return 0;
  1145. return 1;
  1146. }
  1147. /*
  1148. * Called to check deny when READ with all zero stateid or
  1149. * WRITE with all zero or all one stateid
  1150. */
  1151. static __be32
  1152. nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
  1153. {
  1154. struct inode *ino = current_fh->fh_dentry->d_inode;
  1155. struct nfs4_file *fp;
  1156. struct nfs4_stateid *stp;
  1157. __be32 ret;
  1158. dprintk("NFSD: nfs4_share_conflict\n");
  1159. fp = find_file(ino);
  1160. if (!fp)
  1161. return nfs_ok;
  1162. ret = nfserr_locked;
  1163. /* Search for conflicting share reservations */
  1164. list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
  1165. if (test_bit(deny_type, &stp->st_deny_bmap) ||
  1166. test_bit(NFS4_SHARE_DENY_BOTH, &stp->st_deny_bmap))
  1167. goto out;
  1168. }
  1169. ret = nfs_ok;
  1170. out:
  1171. put_nfs4_file(fp);
  1172. return ret;
  1173. }
  1174. static inline void
  1175. nfs4_file_downgrade(struct file *filp, unsigned int share_access)
  1176. {
  1177. if (share_access & NFS4_SHARE_ACCESS_WRITE) {
  1178. put_write_access(filp->f_path.dentry->d_inode);
  1179. filp->f_mode = (filp->f_mode | FMODE_READ) & ~FMODE_WRITE;
  1180. }
  1181. }
  1182. /*
  1183. * Recall a delegation
  1184. */
  1185. static int
  1186. do_recall(void *__dp)
  1187. {
  1188. struct nfs4_delegation *dp = __dp;
  1189. daemonize("nfsv4-recall");
  1190. nfsd4_cb_recall(dp);
  1191. return 0;
  1192. }
  1193. /*
  1194. * Spawn a thread to perform a recall on the delegation represented
  1195. * by the lease (file_lock)
  1196. *
  1197. * Called from break_lease() with lock_kernel() held.
  1198. * Note: we assume break_lease will only call this *once* for any given
  1199. * lease.
  1200. */
  1201. static
  1202. void nfsd_break_deleg_cb(struct file_lock *fl)
  1203. {
  1204. struct nfs4_delegation *dp= (struct nfs4_delegation *)fl->fl_owner;
  1205. struct task_struct *t;
  1206. dprintk("NFSD nfsd_break_deleg_cb: dp %p fl %p\n",dp,fl);
  1207. if (!dp)
  1208. return;
  1209. /* We're assuming the state code never drops its reference
  1210. * without first removing the lease. Since we're in this lease
  1211. * callback (and since the lease code is serialized by the kernel
  1212. * lock) we know the server hasn't removed the lease yet, we know
  1213. * it's safe to take a reference: */
  1214. atomic_inc(&dp->dl_count);
  1215. spin_lock(&recall_lock);
  1216. list_add_tail(&dp->dl_recall_lru, &del_recall_lru);
  1217. spin_unlock(&recall_lock);
  1218. /* only place dl_time is set. protected by lock_kernel*/
  1219. dp->dl_time = get_seconds();
  1220. /* XXX need to merge NFSD_LEASE_TIME with fs/locks.c:lease_break_time */
  1221. fl->fl_break_time = jiffies + NFSD_LEASE_TIME * HZ;
  1222. t = kthread_run(do_recall, dp, "%s", "nfs4_cb_recall");
  1223. if (IS_ERR(t)) {
  1224. struct nfs4_client *clp = dp->dl_client;
  1225. printk(KERN_INFO "NFSD: Callback thread failed for "
  1226. "for client (clientid %08x/%08x)\n",
  1227. clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
  1228. nfs4_put_delegation(dp);
  1229. }
  1230. }
  1231. /*
  1232. * The file_lock is being reapd.
  1233. *
  1234. * Called by locks_free_lock() with lock_kernel() held.
  1235. */
  1236. static
  1237. void nfsd_release_deleg_cb(struct file_lock *fl)
  1238. {
  1239. struct nfs4_delegation *dp = (struct nfs4_delegation *)fl->fl_owner;
  1240. dprintk("NFSD nfsd_release_deleg_cb: fl %p dp %p dl_count %d\n", fl,dp, atomic_read(&dp->dl_count));
  1241. if (!(fl->fl_flags & FL_LEASE) || !dp)
  1242. return;
  1243. dp->dl_flock = NULL;
  1244. }
  1245. /*
  1246. * Set the delegation file_lock back pointer.
  1247. *
  1248. * Called from __setlease() with lock_kernel() held.
  1249. */
  1250. static
  1251. void nfsd_copy_lock_deleg_cb(struct file_lock *new, struct file_lock *fl)
  1252. {
  1253. struct nfs4_delegation *dp = (struct nfs4_delegation *)new->fl_owner;
  1254. dprintk("NFSD: nfsd_copy_lock_deleg_cb: new fl %p dp %p\n", new, dp);
  1255. if (!dp)
  1256. return;
  1257. dp->dl_flock = new;
  1258. }
  1259. /*
  1260. * Called from __setlease() with lock_kernel() held
  1261. */
  1262. static
  1263. int nfsd_same_client_deleg_cb(struct file_lock *onlist, struct file_lock *try)
  1264. {
  1265. struct nfs4_delegation *onlistd =
  1266. (struct nfs4_delegation *)onlist->fl_owner;
  1267. struct nfs4_delegation *tryd =
  1268. (struct nfs4_delegation *)try->fl_owner;
  1269. if (onlist->fl_lmops != try->fl_lmops)
  1270. return 0;
  1271. return onlistd->dl_client == tryd->dl_client;
  1272. }
  1273. static
  1274. int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
  1275. {
  1276. if (arg & F_UNLCK)
  1277. return lease_modify(onlist, arg);
  1278. else
  1279. return -EAGAIN;
  1280. }
  1281. static struct lock_manager_operations nfsd_lease_mng_ops = {
  1282. .fl_break = nfsd_break_deleg_cb,
  1283. .fl_release_private = nfsd_release_deleg_cb,
  1284. .fl_copy_lock = nfsd_copy_lock_deleg_cb,
  1285. .fl_mylease = nfsd_same_client_deleg_cb,
  1286. .fl_change = nfsd_change_deleg_cb,
  1287. };
  1288. __be32
  1289. nfsd4_process_open1(struct nfsd4_open *open)
  1290. {
  1291. clientid_t *clientid = &open->op_clientid;
  1292. struct nfs4_client *clp = NULL;
  1293. unsigned int strhashval;
  1294. struct nfs4_stateowner *sop = NULL;
  1295. if (!check_name(open->op_owner))
  1296. return nfserr_inval;
  1297. if (STALE_CLIENTID(&open->op_clientid))
  1298. return nfserr_stale_clientid;
  1299. strhashval = ownerstr_hashval(clientid->cl_id, open->op_owner);
  1300. sop = find_openstateowner_str(strhashval, open);
  1301. open->op_stateowner = sop;
  1302. if (!sop) {
  1303. /* Make sure the client's lease hasn't expired. */
  1304. clp = find_confirmed_client(clientid);
  1305. if (clp == NULL)
  1306. return nfserr_expired;
  1307. goto renew;
  1308. }
  1309. if (!sop->so_confirmed) {
  1310. /* Replace unconfirmed owners without checking for replay. */
  1311. clp = sop->so_client;
  1312. release_stateowner(sop);
  1313. open->op_stateowner = NULL;
  1314. goto renew;
  1315. }
  1316. if (open->op_seqid == sop->so_seqid - 1) {
  1317. if (sop->so_replay.rp_buflen)
  1318. return nfserr_replay_me;
  1319. /* The original OPEN failed so spectacularly
  1320. * that we don't even have replay data saved!
  1321. * Therefore, we have no choice but to continue
  1322. * processing this OPEN; presumably, we'll
  1323. * fail again for the same reason.
  1324. */
  1325. dprintk("nfsd4_process_open1: replay with no replay cache\n");
  1326. goto renew;
  1327. }
  1328. if (open->op_seqid != sop->so_seqid)
  1329. return nfserr_bad_seqid;
  1330. renew:
  1331. if (open->op_stateowner == NULL) {
  1332. sop = alloc_init_open_stateowner(strhashval, clp, open);
  1333. if (sop == NULL)
  1334. return nfserr_resource;
  1335. open->op_stateowner = sop;
  1336. }
  1337. list_del_init(&sop->so_close_lru);
  1338. renew_client(sop->so_client);
  1339. return nfs_ok;
  1340. }
  1341. static inline __be32
  1342. nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
  1343. {
  1344. if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
  1345. return nfserr_openmode;
  1346. else
  1347. return nfs_ok;
  1348. }
  1349. static struct nfs4_delegation *
  1350. find_delegation_file(struct nfs4_file *fp, stateid_t *stid)
  1351. {
  1352. struct nfs4_delegation *dp;
  1353. list_for_each_entry(dp, &fp->fi_delegations, dl_perfile) {
  1354. if (dp->dl_stateid.si_stateownerid == stid->si_stateownerid)
  1355. return dp;
  1356. }
  1357. return NULL;
  1358. }
  1359. static __be32
  1360. nfs4_check_deleg(struct nfs4_file *fp, struct nfsd4_open *open,
  1361. struct nfs4_delegation **dp)
  1362. {
  1363. int flags;
  1364. __be32 status = nfserr_bad_stateid;
  1365. *dp = find_delegation_file(fp, &open->op_delegate_stateid);
  1366. if (*dp == NULL)
  1367. goto out;
  1368. flags = open->op_share_access == NFS4_SHARE_ACCESS_READ ?
  1369. RD_STATE : WR_STATE;
  1370. status = nfs4_check_delegmode(*dp, flags);
  1371. if (status)
  1372. *dp = NULL;
  1373. out:
  1374. if (open->op_claim_type != NFS4_OPEN_CLAIM_DELEGATE_CUR)
  1375. return nfs_ok;
  1376. if (status)
  1377. return status;
  1378. open->op_stateowner->so_confirmed = 1;
  1379. return nfs_ok;
  1380. }
  1381. static __be32
  1382. nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_stateid **stpp)
  1383. {
  1384. struct nfs4_stateid *local;
  1385. __be32 status = nfserr_share_denied;
  1386. struct nfs4_stateowner *sop = open->op_stateowner;
  1387. list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
  1388. /* ignore lock owners */
  1389. if (local->st_stateowner->so_is_open_owner == 0)
  1390. continue;
  1391. /* remember if we have seen this open owner */
  1392. if (local->st_stateowner == sop)
  1393. *stpp = local;
  1394. /* check for conflicting share reservations */
  1395. if (!test_share(local, open))
  1396. goto out;
  1397. }
  1398. status = 0;
  1399. out:
  1400. return status;
  1401. }
  1402. static inline struct nfs4_stateid *
  1403. nfs4_alloc_stateid(void)
  1404. {
  1405. return kmem_cache_alloc(stateid_slab, GFP_KERNEL);
  1406. }
  1407. static __be32
  1408. nfs4_new_open(struct svc_rqst *rqstp, struct nfs4_stateid **stpp,
  1409. struct nfs4_delegation *dp,
  1410. struct svc_fh *cur_fh, int flags)
  1411. {
  1412. struct nfs4_stateid *stp;
  1413. stp = nfs4_alloc_stateid();
  1414. if (stp == NULL)
  1415. return nfserr_resource;
  1416. if (dp) {
  1417. get_file(dp->dl_vfs_file);
  1418. stp->st_vfs_file = dp->dl_vfs_file;
  1419. } else {
  1420. __be32 status;
  1421. status = nfsd_open(rqstp, cur_fh, S_IFREG, flags,
  1422. &stp->st_vfs_file);
  1423. if (status) {
  1424. if (status == nfserr_dropit)
  1425. status = nfserr_jukebox;
  1426. kmem_cache_free(stateid_slab, stp);
  1427. return status;
  1428. }
  1429. }
  1430. *stpp = stp;
  1431. return 0;
  1432. }
  1433. static inline __be32
  1434. nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
  1435. struct nfsd4_open *open)
  1436. {
  1437. struct iattr iattr = {
  1438. .ia_valid = ATTR_SIZE,
  1439. .ia_size = 0,
  1440. };
  1441. if (!open->op_truncate)
  1442. return 0;
  1443. if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
  1444. return nfserr_inval;
  1445. return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
  1446. }
  1447. static __be32
  1448. nfs4_upgrade_open(struct svc_rqst *rqstp, struct svc_fh *cur_fh, struct nfs4_stateid *stp, struct nfsd4_open *open)
  1449. {
  1450. struct file *filp = stp->st_vfs_file;
  1451. struct inode *inode = filp->f_path.dentry->d_inode;
  1452. unsigned int share_access, new_writer;
  1453. __be32 status;
  1454. set_access(&share_access, stp->st_access_bmap);
  1455. new_writer = (~share_access) & open->op_share_access
  1456. & NFS4_SHARE_ACCESS_WRITE;
  1457. if (new_writer) {
  1458. int err = get_write_access(inode);
  1459. if (err)
  1460. return nfserrno(err);
  1461. }
  1462. status = nfsd4_truncate(rqstp, cur_fh, open);
  1463. if (status) {
  1464. if (new_writer)
  1465. put_write_access(inode);
  1466. return status;
  1467. }
  1468. /* remember the open */
  1469. filp->f_mode |= open->op_share_access;
  1470. set_bit(open->op_share_access, &stp->st_access_bmap);
  1471. set_bit(open->op_share_deny, &stp->st_deny_bmap);
  1472. return nfs_ok;
  1473. }
  1474. static void
  1475. nfs4_set_claim_prev(struct nfsd4_open *open)
  1476. {
  1477. open->op_stateowner->so_confirmed = 1;
  1478. open->op_stateowner->so_client->cl_firststate = 1;
  1479. }
  1480. /*
  1481. * Attempt to hand out a delegation.
  1482. */
  1483. static void
  1484. nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open, struct nfs4_stateid *stp)
  1485. {
  1486. struct nfs4_delegation *dp;
  1487. struct nfs4_stateowner *sop = stp->st_stateowner;
  1488. struct nfs4_callback *cb = &sop->so_client->cl_callback;
  1489. struct file_lock fl, *flp = &fl;
  1490. int status, flag = 0;
  1491. flag = NFS4_OPEN_DELEGATE_NONE;
  1492. open->op_recall = 0;
  1493. switch (open->op_claim_type) {
  1494. case NFS4_OPEN_CLAIM_PREVIOUS:
  1495. if (!atomic_read(&cb->cb_set))
  1496. open->op_recall = 1;
  1497. flag = open->op_delegate_type;
  1498. if (flag == NFS4_OPEN_DELEGATE_NONE)
  1499. goto out;
  1500. break;
  1501. case NFS4_OPEN_CLAIM_NULL:
  1502. /* Let's not give out any delegations till everyone's
  1503. * had the chance to reclaim theirs.... */
  1504. if (nfs4_in_grace())
  1505. goto out;
  1506. if (!atomic_read(&cb->cb_set) || !sop->so_confirmed)
  1507. goto out;
  1508. if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
  1509. flag = NFS4_OPEN_DELEGATE_WRITE;
  1510. else
  1511. flag = NFS4_OPEN_DELEGATE_READ;
  1512. break;
  1513. default:
  1514. goto out;
  1515. }
  1516. dp = alloc_init_deleg(sop->so_client, stp, fh, flag);
  1517. if (dp == NULL) {
  1518. flag = NFS4_OPEN_DELEGATE_NONE;
  1519. goto out;
  1520. }
  1521. locks_init_lock(&fl);
  1522. fl.fl_lmops = &nfsd_lease_mng_ops;
  1523. fl.fl_flags = FL_LEASE;
  1524. fl.fl_end = OFFSET_MAX;
  1525. fl.fl_owner = (fl_owner_t)dp;
  1526. fl.fl_file = stp->st_vfs_file;
  1527. fl.fl_pid = current->tgid;
  1528. /* setlease checks to see if delegation should be handed out.
  1529. * the lock_manager callbacks fl_mylease and fl_change are used
  1530. */
  1531. if ((status = setlease(stp->st_vfs_file,
  1532. flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK, &flp))) {
  1533. dprintk("NFSD: setlease failed [%d], no delegation\n", status);
  1534. unhash_delegation(dp);
  1535. flag = NFS4_OPEN_DELEGATE_NONE;
  1536. goto out;
  1537. }
  1538. memcpy(&open->op_delegate_stateid, &dp->dl_stateid, sizeof(dp->dl_stateid));
  1539. dprintk("NFSD: delegation stateid=(%08x/%08x/%08x/%08x)\n\n",
  1540. dp->dl_stateid.si_boot,
  1541. dp->dl_stateid.si_stateownerid,
  1542. dp->dl_stateid.si_fileid,
  1543. dp->dl_stateid.si_generation);
  1544. out:
  1545. if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS
  1546. && flag == NFS4_OPEN_DELEGATE_NONE
  1547. && open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE)
  1548. printk("NFSD: WARNING: refusing delegation reclaim\n");
  1549. open->op_delegate_type = flag;
  1550. }
  1551. /*
  1552. * called with nfs4_lock_state() held.
  1553. */
  1554. __be32
  1555. nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
  1556. {
  1557. struct nfs4_file *fp = NULL;
  1558. struct inode *ino = current_fh->fh_dentry->d_inode;
  1559. struct nfs4_stateid *stp = NULL;
  1560. struct nfs4_delegation *dp = NULL;
  1561. __be32 status;
  1562. status = nfserr_inval;
  1563. if (!access_valid(open->op_share_access)
  1564. || !deny_valid(open->op_share_deny))
  1565. goto out;
  1566. /*
  1567. * Lookup file; if found, lookup stateid and check open request,
  1568. * and check for delegations in the process of being recalled.
  1569. * If not found, create the nfs4_file struct
  1570. */
  1571. fp = find_file(ino);
  1572. if (fp) {
  1573. if ((status = nfs4_check_open(fp, open, &stp)))
  1574. goto out;
  1575. status = nfs4_check_deleg(fp, open, &dp);
  1576. if (status)
  1577. goto out;
  1578. } else {
  1579. status = nfserr_bad_stateid;
  1580. if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
  1581. goto out;
  1582. status = nfserr_resource;
  1583. fp = alloc_init_file(ino);
  1584. if (fp == NULL)
  1585. goto out;
  1586. }
  1587. /*
  1588. * OPEN the file, or upgrade an existing OPEN.
  1589. * If truncate fails, the OPEN fails.
  1590. */
  1591. if (stp) {
  1592. /* Stateid was found, this is an OPEN upgrade */
  1593. status = nfs4_upgrade_open(rqstp, current_fh, stp, open);
  1594. if (status)
  1595. goto out;
  1596. update_stateid(&stp->st_stateid);
  1597. } else {
  1598. /* Stateid was not found, this is a new OPEN */
  1599. int flags = 0;
  1600. if (open->op_share_access & NFS4_SHARE_ACCESS_READ)
  1601. flags |= MAY_READ;
  1602. if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
  1603. flags |= MAY_WRITE;
  1604. status = nfs4_new_open(rqstp, &stp, dp, current_fh, flags);
  1605. if (status)
  1606. goto out;
  1607. init_stateid(stp, fp, open);
  1608. status = nfsd4_truncate(rqstp, current_fh, open);
  1609. if (status) {
  1610. release_stateid(stp, OPEN_STATE);
  1611. goto out;
  1612. }
  1613. }
  1614. memcpy(&open->op_stateid, &stp->st_stateid, sizeof(stateid_t));
  1615. /*
  1616. * Attempt to hand out a delegation. No error return, because the
  1617. * OPEN succeeds even if we fail.
  1618. */
  1619. nfs4_open_delegation(current_fh, open, stp);
  1620. status = nfs_ok;
  1621. dprintk("nfs4_process_open2: stateid=(%08x/%08x/%08x/%08x)\n",
  1622. stp->st_stateid.si_boot, stp->st_stateid.si_stateownerid,
  1623. stp->st_stateid.si_fileid, stp->st_stateid.si_generation);
  1624. out:
  1625. if (fp)
  1626. put_nfs4_file(fp);
  1627. if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
  1628. nfs4_set_claim_prev(open);
  1629. /*
  1630. * To finish the open response, we just need to set the rflags.
  1631. */
  1632. open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
  1633. if (!open->op_stateowner->so_confirmed)
  1634. open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
  1635. return status;
  1636. }
  1637. static struct workqueue_struct *laundry_wq;
  1638. static void laundromat_main(struct work_struct *);
  1639. static DECLARE_DELAYED_WORK(laundromat_work, laundromat_main);
  1640. __be32
  1641. nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
  1642. clientid_t *clid)
  1643. {
  1644. struct nfs4_client *clp;
  1645. __be32 status;
  1646. nfs4_lock_state();
  1647. dprintk("process_renew(%08x/%08x): starting\n",
  1648. clid->cl_boot, clid->cl_id);
  1649. status = nfserr_stale_clientid;
  1650. if (STALE_CLIENTID(clid))
  1651. goto out;
  1652. clp = find_confirmed_client(clid);
  1653. status = nfserr_expired;
  1654. if (clp == NULL) {
  1655. /* We assume the client took too long to RENEW. */
  1656. dprintk("nfsd4_renew: clientid not found!\n");
  1657. goto out;
  1658. }
  1659. renew_client(clp);
  1660. status = nfserr_cb_path_down;
  1661. if (!list_empty(&clp->cl_delegations)
  1662. && !atomic_read(&clp->cl_callback.cb_set))
  1663. goto out;
  1664. status = nfs_ok;
  1665. out:
  1666. nfs4_unlock_state();
  1667. return status;
  1668. }
  1669. static void
  1670. end_grace(void)
  1671. {
  1672. dprintk("NFSD: end of grace period\n");
  1673. nfsd4_recdir_purge_old();
  1674. in_grace = 0;
  1675. }
  1676. static time_t
  1677. nfs4_laundromat(void)
  1678. {
  1679. struct nfs4_client *clp;
  1680. struct nfs4_stateowner *sop;
  1681. struct nfs4_delegation *dp;
  1682. struct list_head *pos, *next, reaplist;
  1683. time_t cutoff = get_seconds() - NFSD_LEASE_TIME;
  1684. time_t t, clientid_val = NFSD_LEASE_TIME;
  1685. time_t u, test_val = NFSD_LEASE_TIME;
  1686. nfs4_lock_state();
  1687. dprintk("NFSD: laundromat service - starting\n");
  1688. if (in_grace)
  1689. end_grace();
  1690. list_for_each_safe(pos, next, &client_lru) {
  1691. clp = list_entry(pos, struct nfs4_client, cl_lru);
  1692. if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
  1693. t = clp->cl_time - cutoff;
  1694. if (clientid_val > t)
  1695. clientid_val = t;
  1696. break;
  1697. }
  1698. dprintk("NFSD: purging unused client (clientid %08x)\n",
  1699. clp->cl_clientid.cl_id);
  1700. nfsd4_remove_clid_dir(clp);
  1701. expire_client(clp);
  1702. }
  1703. INIT_LIST_HEAD(&reaplist);
  1704. spin_lock(&recall_lock);
  1705. list_for_each_safe(pos, next, &del_recall_lru) {
  1706. dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
  1707. if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
  1708. u = dp->dl_time - cutoff;
  1709. if (test_val > u)
  1710. test_val = u;
  1711. break;
  1712. }
  1713. dprintk("NFSD: purging unused delegation dp %p, fp %p\n",
  1714. dp, dp->dl_flock);
  1715. list_move(&dp->dl_recall_lru, &reaplist);
  1716. }
  1717. spin_unlock(&recall_lock);
  1718. list_for_each_safe(pos, next, &reaplist) {
  1719. dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
  1720. list_del_init(&dp->dl_recall_lru);
  1721. unhash_delegation(dp);
  1722. }
  1723. test_val = NFSD_LEASE_TIME;
  1724. list_for_each_safe(pos, next, &close_lru) {
  1725. sop = list_entry(pos, struct nfs4_stateowner, so_close_lru);
  1726. if (time_after((unsigned long)sop->so_time, (unsigned long)cutoff)) {
  1727. u = sop->so_time - cutoff;
  1728. if (test_val > u)
  1729. test_val = u;
  1730. break;
  1731. }
  1732. dprintk("NFSD: purging unused open stateowner (so_id %d)\n",
  1733. sop->so_id);
  1734. release_stateowner(sop);
  1735. }
  1736. if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT)
  1737. clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT;
  1738. nfs4_unlock_state();
  1739. return clientid_val;
  1740. }
  1741. void
  1742. laundromat_main(struct work_struct *not_used)
  1743. {
  1744. time_t t;
  1745. t = nfs4_laundromat();
  1746. dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
  1747. queue_delayed_work(laundry_wq, &laundromat_work, t*HZ);
  1748. }
  1749. static struct nfs4_stateowner *
  1750. search_close_lru(u32 st_id, int flags)
  1751. {
  1752. struct nfs4_stateowner *local = NULL;
  1753. if (flags & CLOSE_STATE) {
  1754. list_for_each_entry(local, &close_lru, so_close_lru) {
  1755. if (local->so_id == st_id)
  1756. return local;
  1757. }
  1758. }
  1759. return NULL;
  1760. }
  1761. static inline int
  1762. nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stateid *stp)
  1763. {
  1764. return fhp->fh_dentry->d_inode != stp->st_vfs_file->f_path.dentry->d_inode;
  1765. }
  1766. static int
  1767. STALE_STATEID(stateid_t *stateid)
  1768. {
  1769. if (stateid->si_boot == boot_time)
  1770. return 0;
  1771. dprintk("NFSD: stale stateid (%08x/%08x/%08x/%08x)!\n",
  1772. stateid->si_boot, stateid->si_stateownerid, stateid->si_fileid,
  1773. stateid->si_generation);
  1774. return 1;
  1775. }
  1776. static inline int
  1777. access_permit_read(unsigned long access_bmap)
  1778. {
  1779. return test_bit(NFS4_SHARE_ACCESS_READ, &access_bmap) ||
  1780. test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap) ||
  1781. test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap);
  1782. }
  1783. static inline int
  1784. access_permit_write(unsigned long access_bmap)
  1785. {
  1786. return test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap) ||
  1787. test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap);
  1788. }
  1789. static
  1790. __be32 nfs4_check_openmode(struct nfs4_stateid *stp, int flags)
  1791. {
  1792. __be32 status = nfserr_openmode;
  1793. if ((flags & WR_STATE) && (!access_permit_write(stp->st_access_bmap)))
  1794. goto out;
  1795. if ((flags & RD_STATE) && (!access_permit_read(stp->st_access_bmap)))
  1796. goto out;
  1797. status = nfs_ok;
  1798. out:
  1799. return status;
  1800. }
  1801. static inline __be32
  1802. check_special_stateids(svc_fh *current_fh, stateid_t *stateid, int flags)
  1803. {
  1804. /* Trying to call delegreturn with a special stateid? Yuch: */
  1805. if (!(flags & (RD_STATE | WR_STATE)))
  1806. return nfserr_bad_stateid;
  1807. else if (ONE_STATEID(stateid) && (flags & RD_STATE))
  1808. return nfs_ok;
  1809. else if (nfs4_in_grace()) {
  1810. /* Answer in remaining cases depends on existance of
  1811. * conflicting state; so we must wait out the grace period. */
  1812. return nfserr_grace;
  1813. } else if (flags & WR_STATE)
  1814. return nfs4_share_conflict(current_fh,
  1815. NFS4_SHARE_DENY_WRITE);
  1816. else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
  1817. return nfs4_share_conflict(current_fh,
  1818. NFS4_SHARE_DENY_READ);
  1819. }
  1820. /*
  1821. * Allow READ/WRITE during grace period on recovered state only for files
  1822. * that are not able to provide mandatory locking.
  1823. */
  1824. static inline int
  1825. io_during_grace_disallowed(struct inode *inode, int flags)
  1826. {
  1827. return nfs4_in_grace() && (flags & (RD_STATE | WR_STATE))
  1828. && MANDATORY_LOCK(inode);
  1829. }
  1830. /*
  1831. * Checks for stateid operations
  1832. */
  1833. __be32
  1834. nfs4_preprocess_stateid_op(struct svc_fh *current_fh, stateid_t *stateid, int flags, struct file **filpp)
  1835. {
  1836. struct nfs4_stateid *stp = NULL;
  1837. struct nfs4_delegation *dp = NULL;
  1838. stateid_t *stidp;
  1839. struct inode *ino = current_fh->fh_dentry->d_inode;
  1840. __be32 status;
  1841. dprintk("NFSD: preprocess_stateid_op: stateid = (%08x/%08x/%08x/%08x)\n",
  1842. stateid->si_boot, stateid->si_stateownerid,
  1843. stateid->si_fileid, stateid->si_generation);
  1844. if (filpp)
  1845. *filpp = NULL;
  1846. if (io_during_grace_disallowed(ino, flags))
  1847. return nfserr_grace;
  1848. if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
  1849. return check_special_stateids(current_fh, stateid, flags);
  1850. /* STALE STATEID */
  1851. status = nfserr_stale_stateid;
  1852. if (STALE_STATEID(stateid))
  1853. goto out;
  1854. /* BAD STATEID */
  1855. status = nfserr_bad_stateid;
  1856. if (!stateid->si_fileid) { /* delegation stateid */
  1857. if(!(dp = find_delegation_stateid(ino, stateid))) {
  1858. dprintk("NFSD: delegation stateid not found\n");
  1859. goto out;
  1860. }
  1861. stidp = &dp->dl_stateid;
  1862. } else { /* open or lock stateid */
  1863. if (!(stp = find_stateid(stateid, flags))) {
  1864. dprintk("NFSD: open or lock stateid not found\n");
  1865. goto out;
  1866. }
  1867. if ((flags & CHECK_FH) && nfs4_check_fh(current_fh, stp))
  1868. goto out;
  1869. if (!stp->st_stateowner->so_confirmed)
  1870. goto out;
  1871. stidp = &stp->st_stateid;
  1872. }
  1873. if (stateid->si_generation > stidp->si_generation)
  1874. goto out;
  1875. /* OLD STATEID */
  1876. status = nfserr_old_stateid;
  1877. if (stateid->si_generation < stidp->si_generation)
  1878. goto out;
  1879. if (stp) {
  1880. if ((status = nfs4_check_openmode(stp,flags)))
  1881. goto out;
  1882. renew_client(stp->st_stateowner->so_client);
  1883. if (filpp)
  1884. *filpp = stp->st_vfs_file;
  1885. } else if (dp) {
  1886. if ((status = nfs4_check_delegmode(dp, flags)))
  1887. goto out;
  1888. renew_client(dp->dl_client);
  1889. if (flags & DELEG_RET)
  1890. unhash_delegation(dp);
  1891. if (filpp)
  1892. *filpp = dp->dl_vfs_file;
  1893. }
  1894. status = nfs_ok;
  1895. out:
  1896. return status;
  1897. }
  1898. static inline int
  1899. setlkflg (int type)
  1900. {
  1901. return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
  1902. RD_STATE : WR_STATE;
  1903. }
  1904. /*
  1905. * Checks for sequence id mutating operations.
  1906. */
  1907. static __be32
  1908. nfs4_preprocess_seqid_op(struct svc_fh *current_fh, u32 seqid, stateid_t *stateid, int flags, struct nfs4_stateowner **sopp, struct nfs4_stateid **stpp, struct nfsd4_lock *lock)
  1909. {
  1910. struct nfs4_stateid *stp;
  1911. struct nfs4_stateowner *sop;
  1912. dprintk("NFSD: preprocess_seqid_op: seqid=%d "
  1913. "stateid = (%08x/%08x/%08x/%08x)\n", seqid,
  1914. stateid->si_boot, stateid->si_stateownerid, stateid->si_fileid,
  1915. stateid->si_generation);
  1916. *stpp = NULL;
  1917. *sopp = NULL;
  1918. if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {
  1919. printk("NFSD: preprocess_seqid_op: magic stateid!\n");
  1920. return nfserr_bad_stateid;
  1921. }
  1922. if (STALE_STATEID(stateid))
  1923. return nfserr_stale_stateid;
  1924. /*
  1925. * We return BAD_STATEID if filehandle doesn't match stateid,
  1926. * the confirmed flag is incorrecly set, or the generation
  1927. * number is incorrect.
  1928. */
  1929. stp = find_stateid(stateid, flags);
  1930. if (stp == NULL) {
  1931. /*
  1932. * Also, we should make sure this isn't just the result of
  1933. * a replayed close:
  1934. */
  1935. sop = search_close_lru(stateid->si_stateownerid, flags);
  1936. if (sop == NULL)
  1937. return nfserr_bad_stateid;
  1938. *sopp = sop;
  1939. goto check_replay;
  1940. }
  1941. if (lock) {
  1942. struct nfs4_stateowner *sop = stp->st_stateowner;
  1943. clientid_t *lockclid = &lock->v.new.clientid;
  1944. struct nfs4_client *clp = sop->so_client;
  1945. int lkflg = 0;
  1946. __be32 status;
  1947. lkflg = setlkflg(lock->lk_type);
  1948. if (lock->lk_is_new) {
  1949. if (!sop->so_is_open_owner)
  1950. return nfserr_bad_stateid;
  1951. if (!cmp_clid(&clp->cl_clientid, lockclid))
  1952. return nfserr_bad_stateid;
  1953. /* stp is the open stateid */
  1954. status = nfs4_check_openmode(stp, lkflg);
  1955. if (status)
  1956. return status;
  1957. } else {
  1958. /* stp is the lock stateid */
  1959. status = nfs4_check_openmode(stp->st_openstp, lkflg);
  1960. if (status)
  1961. return status;
  1962. }
  1963. }
  1964. if ((flags & CHECK_FH) && nfs4_check_fh(current_fh, stp)) {
  1965. printk("NFSD: preprocess_seqid_op: fh-stateid mismatch!\n");
  1966. return nfserr_bad_stateid;
  1967. }
  1968. *stpp = stp;
  1969. *sopp = sop = stp->st_stateowner;
  1970. /*
  1971. * We now validate the seqid and stateid generation numbers.
  1972. * For the moment, we ignore the possibility of
  1973. * generation number wraparound.
  1974. */
  1975. if (seqid != sop->so_seqid)
  1976. goto check_replay;
  1977. if (sop->so_confirmed && flags & CONFIRM) {
  1978. printk("NFSD: preprocess_seqid_op: expected"
  1979. " unconfirmed stateowner!\n");
  1980. return nfserr_bad_stateid;
  1981. }
  1982. if (!sop->so_confirmed && !(flags & CONFIRM)) {
  1983. printk("NFSD: preprocess_seqid_op: stateowner not"
  1984. " confirmed yet!\n");
  1985. return nfserr_bad_stateid;
  1986. }
  1987. if (stateid->si_generation > stp->st_stateid.si_generation) {
  1988. printk("NFSD: preprocess_seqid_op: future stateid?!\n");
  1989. return nfserr_bad_stateid;
  1990. }
  1991. if (stateid->si_generation < stp->st_stateid.si_generation) {
  1992. printk("NFSD: preprocess_seqid_op: old stateid!\n");
  1993. return nfserr_old_stateid;
  1994. }
  1995. renew_client(sop->so_client);
  1996. return nfs_ok;
  1997. check_replay:
  1998. if (seqid == sop->so_seqid - 1) {
  1999. dprintk("NFSD: preprocess_seqid_op: retransmission?\n");
  2000. /* indicate replay to calling function */
  2001. return nfserr_replay_me;
  2002. }
  2003. printk("NFSD: preprocess_seqid_op: bad seqid (expected %d, got %d)\n",
  2004. sop->so_seqid, seqid);
  2005. *sopp = NULL;
  2006. return nfserr_bad_seqid;
  2007. }
  2008. __be32
  2009. nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
  2010. struct nfsd4_open_confirm *oc)
  2011. {
  2012. __be32 status;
  2013. struct nfs4_stateowner *sop;
  2014. struct nfs4_stateid *stp;
  2015. dprintk("NFSD: nfsd4_open_confirm on file %.*s\n",
  2016. (int)cstate->current_fh.fh_dentry->d_name.len,
  2017. cstate->current_fh.fh_dentry->d_name.name);
  2018. status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
  2019. if (status)
  2020. return status;
  2021. nfs4_lock_state();
  2022. if ((status = nfs4_preprocess_seqid_op(&cstate->current_fh,
  2023. oc->oc_seqid, &oc->oc_req_stateid,
  2024. CHECK_FH | CONFIRM | OPEN_STATE,
  2025. &oc->oc_stateowner, &stp, NULL)))
  2026. goto out;
  2027. sop = oc->oc_stateowner;
  2028. sop->so_confirmed = 1;
  2029. update_stateid(&stp->st_stateid);
  2030. memcpy(&oc->oc_resp_stateid, &stp->st_stateid, sizeof(stateid_t));
  2031. dprintk("NFSD: nfsd4_open_confirm: success, seqid=%d "
  2032. "stateid=(%08x/%08x/%08x/%08x)\n", oc->oc_seqid,
  2033. stp->st_stateid.si_boot,
  2034. stp->st_stateid.si_stateownerid,
  2035. stp->st_stateid.si_fileid,
  2036. stp->st_stateid.si_generation);
  2037. nfsd4_create_clid_dir(sop->so_client);
  2038. out:
  2039. if (oc->oc_stateowner) {
  2040. nfs4_get_stateowner(oc->oc_stateowner);
  2041. cstate->replay_owner = oc->oc_stateowner;
  2042. }
  2043. nfs4_unlock_state();
  2044. return status;
  2045. }
  2046. /*
  2047. * unset all bits in union bitmap (bmap) that
  2048. * do not exist in share (from successful OPEN_DOWNGRADE)
  2049. */
  2050. static void
  2051. reset_union_bmap_access(unsigned long access, unsigned long *bmap)
  2052. {
  2053. int i;
  2054. for (i = 1; i < 4; i++) {
  2055. if ((i & access) != i)
  2056. __clear_bit(i, bmap);
  2057. }
  2058. }
  2059. static void
  2060. reset_union_bmap_deny(unsigned long deny, unsigned long *bmap)
  2061. {
  2062. int i;
  2063. for (i = 0; i < 4; i++) {
  2064. if ((i & deny) != i)
  2065. __clear_bit(i, bmap);
  2066. }
  2067. }
  2068. __be32
  2069. nfsd4_open_downgrade(struct svc_rqst *rqstp,
  2070. struct nfsd4_compound_state *cstate,
  2071. struct nfsd4_open_downgrade *od)
  2072. {
  2073. __be32 status;
  2074. struct nfs4_stateid *stp;
  2075. unsigned int share_access;
  2076. dprintk("NFSD: nfsd4_open_downgrade on file %.*s\n",
  2077. (int)cstate->current_fh.fh_dentry->d_name.len,
  2078. cstate->current_fh.fh_dentry->d_name.name);
  2079. if (!access_valid(od->od_share_access)
  2080. || !deny_valid(od->od_share_deny))
  2081. return nfserr_inval;
  2082. nfs4_lock_state();
  2083. if ((status = nfs4_preprocess_seqid_op(&cstate->current_fh,
  2084. od->od_seqid,
  2085. &od->od_stateid,
  2086. CHECK_FH | OPEN_STATE,
  2087. &od->od_stateowner, &stp, NULL)))
  2088. goto out;
  2089. status = nfserr_inval;
  2090. if (!test_bit(od->od_share_access, &stp->st_access_bmap)) {
  2091. dprintk("NFSD:access not a subset current bitmap: 0x%lx, input access=%08x\n",
  2092. stp->st_access_bmap, od->od_share_access);
  2093. goto out;
  2094. }
  2095. if (!test_bit(od->od_share_deny, &stp->st_deny_bmap)) {
  2096. dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
  2097. stp->st_deny_bmap, od->od_share_deny);
  2098. goto out;
  2099. }
  2100. set_access(&share_access, stp->st_access_bmap);
  2101. nfs4_file_downgrade(stp->st_vfs_file,
  2102. share_access & ~od->od_share_access);
  2103. reset_union_bmap_access(od->od_share_access, &stp->st_access_bmap);
  2104. reset_union_bmap_deny(od->od_share_deny, &stp->st_deny_bmap);
  2105. update_stateid(&stp->st_stateid);
  2106. memcpy(&od->od_stateid, &stp->st_stateid, sizeof(stateid_t));
  2107. status = nfs_ok;
  2108. out:
  2109. if (od->od_stateowner) {
  2110. nfs4_get_stateowner(od->od_stateowner);
  2111. cstate->replay_owner = od->od_stateowner;
  2112. }
  2113. nfs4_unlock_state();
  2114. return status;
  2115. }
  2116. /*
  2117. * nfs4_unlock_state() called after encode
  2118. */
  2119. __be32
  2120. nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
  2121. struct nfsd4_close *close)
  2122. {
  2123. __be32 status;
  2124. struct nfs4_stateid *stp;
  2125. dprintk("NFSD: nfsd4_close on file %.*s\n",
  2126. (int)cstate->current_fh.fh_dentry->d_name.len,
  2127. cstate->current_fh.fh_dentry->d_name.name);
  2128. nfs4_lock_state();
  2129. /* check close_lru for replay */
  2130. if ((status = nfs4_preprocess_seqid_op(&cstate->current_fh,
  2131. close->cl_seqid,
  2132. &close->cl_stateid,
  2133. CHECK_FH | OPEN_STATE | CLOSE_STATE,
  2134. &close->cl_stateowner, &stp, NULL)))
  2135. goto out;
  2136. status = nfs_ok;
  2137. update_stateid(&stp->st_stateid);
  2138. memcpy(&close->cl_stateid, &stp->st_stateid, sizeof(stateid_t));
  2139. /* release_stateid() calls nfsd_close() if needed */
  2140. release_stateid(stp, OPEN_STATE);
  2141. /* place unused nfs4_stateowners on so_close_lru list to be
  2142. * released by the laundromat service after the lease period
  2143. * to enable us to handle CLOSE replay
  2144. */
  2145. if (list_empty(&close->cl_stateowner->so_stateids))
  2146. move_to_close_lru(close->cl_stateowner);
  2147. out:
  2148. if (close->cl_stateowner) {
  2149. nfs4_get_stateowner(close->cl_stateowner);
  2150. cstate->replay_owner = close->cl_stateowner;
  2151. }
  2152. nfs4_unlock_state();
  2153. return status;
  2154. }
  2155. __be32
  2156. nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
  2157. struct nfsd4_delegreturn *dr)
  2158. {
  2159. __be32 status;
  2160. if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
  2161. goto out;
  2162. nfs4_lock_state();
  2163. status = nfs4_preprocess_stateid_op(&cstate->current_fh,
  2164. &dr->dr_stateid, DELEG_RET, NULL);
  2165. nfs4_unlock_state();
  2166. out:
  2167. return status;
  2168. }
  2169. /*
  2170. * Lock owner state (byte-range locks)
  2171. */
  2172. #define LOFF_OVERFLOW(start, len) ((u64)(len) > ~(u64)(start))
  2173. #define LOCK_HASH_BITS 8
  2174. #define LOCK_HASH_SIZE (1 << LOCK_HASH_BITS)
  2175. #define LOCK_HASH_MASK (LOCK_HASH_SIZE - 1)
  2176. #define lockownerid_hashval(id) \
  2177. ((id) & LOCK_HASH_MASK)
  2178. static inline unsigned int
  2179. lock_ownerstr_hashval(struct inode *inode, u32 cl_id,
  2180. struct xdr_netobj *ownername)
  2181. {
  2182. return (file_hashval(inode) + cl_id
  2183. + opaque_hashval(ownername->data, ownername->len))
  2184. & LOCK_HASH_MASK;
  2185. }
  2186. static struct list_head lock_ownerid_hashtbl[LOCK_HASH_SIZE];
  2187. static struct list_head lock_ownerstr_hashtbl[LOCK_HASH_SIZE];
  2188. static struct list_head lockstateid_hashtbl[STATEID_HASH_SIZE];
  2189. static struct nfs4_stateid *
  2190. find_stateid(stateid_t *stid, int flags)
  2191. {
  2192. struct nfs4_stateid *local = NULL;
  2193. u32 st_id = stid->si_stateownerid;
  2194. u32 f_id = stid->si_fileid;
  2195. unsigned int hashval;
  2196. dprintk("NFSD: find_stateid flags 0x%x\n",flags);
  2197. if ((flags & LOCK_STATE) || (flags & RD_STATE) || (flags & WR_STATE)) {
  2198. hashval = stateid_hashval(st_id, f_id);
  2199. list_for_each_entry(local, &lockstateid_hashtbl[hashval], st_hash) {
  2200. if ((local->st_stateid.si_stateownerid == st_id) &&
  2201. (local->st_stateid.si_fileid == f_id))
  2202. return local;
  2203. }
  2204. }
  2205. if ((flags & OPEN_STATE) || (flags & RD_STATE) || (flags & WR_STATE)) {
  2206. hashval = stateid_hashval(st_id, f_id);
  2207. list_for_each_entry(local, &stateid_hashtbl[hashval], st_hash) {
  2208. if ((local->st_stateid.si_stateownerid == st_id) &&
  2209. (local->st_stateid.si_fileid == f_id))
  2210. return local;
  2211. }
  2212. }
  2213. return NULL;
  2214. }
  2215. static struct nfs4_delegation *
  2216. find_delegation_stateid(struct inode *ino, stateid_t *stid)
  2217. {
  2218. struct nfs4_file *fp;
  2219. struct nfs4_delegation *dl;
  2220. dprintk("NFSD:find_delegation_stateid stateid=(%08x/%08x/%08x/%08x)\n",
  2221. stid->si_boot, stid->si_stateownerid,
  2222. stid->si_fileid, stid->si_generation);
  2223. fp = find_file(ino);
  2224. if (!fp)
  2225. return NULL;
  2226. dl = find_delegation_file(fp, stid);
  2227. put_nfs4_file(fp);
  2228. return dl;
  2229. }
  2230. /*
  2231. * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
  2232. * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
  2233. * byte, because of sign extension problems. Since NFSv4 calls for 64-bit
  2234. * locking, this prevents us from being completely protocol-compliant. The
  2235. * real solution to this problem is to start using unsigned file offsets in
  2236. * the VFS, but this is a very deep change!
  2237. */
  2238. static inline void
  2239. nfs4_transform_lock_offset(struct file_lock *lock)
  2240. {
  2241. if (lock->fl_start < 0)
  2242. lock->fl_start = OFFSET_MAX;
  2243. if (lock->fl_end < 0)
  2244. lock->fl_end = OFFSET_MAX;
  2245. }
  2246. /* Hack!: For now, we're defining this just so we can use a pointer to it
  2247. * as a unique cookie to identify our (NFSv4's) posix locks. */
  2248. static struct lock_manager_operations nfsd_posix_mng_ops = {
  2249. };
  2250. static inline void
  2251. nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
  2252. {
  2253. struct nfs4_stateowner *sop;
  2254. unsigned int hval;
  2255. if (fl->fl_lmops == &nfsd_posix_mng_ops) {
  2256. sop = (struct nfs4_stateowner *) fl->fl_owner;
  2257. hval = lockownerid_hashval(sop->so_id);
  2258. kref_get(&sop->so_ref);
  2259. deny->ld_sop = sop;
  2260. deny->ld_clientid = sop->so_client->cl_clientid;
  2261. } else {
  2262. deny->ld_sop = NULL;
  2263. deny->ld_clientid.cl_boot = 0;
  2264. deny->ld_clientid.cl_id = 0;
  2265. }
  2266. deny->ld_start = fl->fl_start;
  2267. deny->ld_length = ~(u64)0;
  2268. if (fl->fl_end != ~(u64)0)
  2269. deny->ld_length = fl->fl_end - fl->fl_start + 1;
  2270. deny->ld_type = NFS4_READ_LT;
  2271. if (fl->fl_type != F_RDLCK)
  2272. deny->ld_type = NFS4_WRITE_LT;
  2273. }
  2274. static struct nfs4_stateowner *
  2275. find_lockstateowner_str(struct inode *inode, clientid_t *clid,
  2276. struct xdr_netobj *owner)
  2277. {
  2278. unsigned int hashval = lock_ownerstr_hashval(inode, clid->cl_id, owner);
  2279. struct nfs4_stateowner *op;
  2280. list_for_each_entry(op, &lock_ownerstr_hashtbl[hashval], so_strhash) {
  2281. if (cmp_owner_str(op, owner, clid))
  2282. return op;
  2283. }
  2284. return NULL;
  2285. }
  2286. /*
  2287. * Alloc a lock owner structure.
  2288. * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has
  2289. * occured.
  2290. *
  2291. * strhashval = lock_ownerstr_hashval
  2292. */
  2293. static struct nfs4_stateowner *
  2294. alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfs4_stateid *open_stp, struct nfsd4_lock *lock) {
  2295. struct nfs4_stateowner *sop;
  2296. struct nfs4_replay *rp;
  2297. unsigned int idhashval;
  2298. if (!(sop = alloc_stateowner(&lock->lk_new_owner)))
  2299. return NULL;
  2300. idhashval = lockownerid_hashval(current_ownerid);
  2301. INIT_LIST_HEAD(&sop->so_idhash);
  2302. INIT_LIST_HEAD(&sop->so_strhash);
  2303. INIT_LIST_HEAD(&sop->so_perclient);
  2304. INIT_LIST_HEAD(&sop->so_stateids);
  2305. INIT_LIST_HEAD(&sop->so_perstateid);
  2306. INIT_LIST_HEAD(&sop->so_close_lru); /* not used */
  2307. sop->so_time = 0;
  2308. list_add(&sop->so_idhash, &lock_ownerid_hashtbl[idhashval]);
  2309. list_add(&sop->so_strhash, &lock_ownerstr_hashtbl[strhashval]);
  2310. list_add(&sop->so_perstateid, &open_stp->st_lockowners);
  2311. sop->so_is_open_owner = 0;
  2312. sop->so_id = current_ownerid++;
  2313. sop->so_client = clp;
  2314. /* It is the openowner seqid that will be incremented in encode in the
  2315. * case of new lockowners; so increment the lock seqid manually: */
  2316. sop->so_seqid = lock->lk_new_lock_seqid + 1;
  2317. sop->so_confirmed = 1;
  2318. rp = &sop->so_replay;
  2319. rp->rp_status = nfserr_serverfault;
  2320. rp->rp_buflen = 0;
  2321. rp->rp_buf = rp->rp_ibuf;
  2322. return sop;
  2323. }
  2324. static struct nfs4_stateid *
  2325. alloc_init_lock_stateid(struct nfs4_stateowner *sop, struct nfs4_file *fp, struct nfs4_stateid *open_stp)
  2326. {
  2327. struct nfs4_stateid *stp;
  2328. unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);
  2329. stp = nfs4_alloc_stateid();
  2330. if (stp == NULL)
  2331. goto out;
  2332. INIT_LIST_HEAD(&stp->st_hash);
  2333. INIT_LIST_HEAD(&stp->st_perfile);
  2334. INIT_LIST_HEAD(&stp->st_perstateowner);
  2335. INIT_LIST_HEAD(&stp->st_lockowners); /* not used */
  2336. list_add(&stp->st_hash, &lockstateid_hashtbl[hashval]);
  2337. list_add(&stp->st_perfile, &fp->fi_stateids);
  2338. list_add(&stp->st_perstateowner, &sop->so_stateids);
  2339. stp->st_stateowner = sop;
  2340. get_nfs4_file(fp);
  2341. stp->st_file = fp;
  2342. stp->st_stateid.si_boot = boot_time;
  2343. stp->st_stateid.si_stateownerid = sop->so_id;
  2344. stp->st_stateid.si_fileid = fp->fi_id;
  2345. stp->st_stateid.si_generation = 0;
  2346. stp->st_vfs_file = open_stp->st_vfs_file; /* FIXME refcount?? */
  2347. stp->st_access_bmap = open_stp->st_access_bmap;
  2348. stp->st_deny_bmap = open_stp->st_deny_bmap;
  2349. stp->st_openstp = open_stp;
  2350. out:
  2351. return stp;
  2352. }
  2353. static int
  2354. check_lock_length(u64 offset, u64 length)
  2355. {
  2356. return ((length == 0) || ((length != ~(u64)0) &&
  2357. LOFF_OVERFLOW(offset, length)));
  2358. }
  2359. /*
  2360. * LOCK operation
  2361. */
  2362. __be32
  2363. nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
  2364. struct nfsd4_lock *lock)
  2365. {
  2366. struct nfs4_stateowner *open_sop = NULL;
  2367. struct nfs4_stateowner *lock_sop = NULL;
  2368. struct nfs4_stateid *lock_stp;
  2369. struct file *filp;
  2370. struct file_lock file_lock;
  2371. struct file_lock conflock;
  2372. __be32 status = 0;
  2373. unsigned int strhashval;
  2374. int err;
  2375. dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
  2376. (long long) lock->lk_offset,
  2377. (long long) lock->lk_length);
  2378. if (check_lock_length(lock->lk_offset, lock->lk_length))
  2379. return nfserr_inval;
  2380. if ((status = fh_verify(rqstp, &cstate->current_fh,
  2381. S_IFREG, MAY_LOCK))) {
  2382. dprintk("NFSD: nfsd4_lock: permission denied!\n");
  2383. return status;
  2384. }
  2385. nfs4_lock_state();
  2386. if (lock->lk_is_new) {
  2387. /*
  2388. * Client indicates that this is a new lockowner.
  2389. * Use open owner and open stateid to create lock owner and
  2390. * lock stateid.
  2391. */
  2392. struct nfs4_stateid *open_stp = NULL;
  2393. struct nfs4_file *fp;
  2394. status = nfserr_stale_clientid;
  2395. if (STALE_CLIENTID(&lock->lk_new_clientid))
  2396. goto out;
  2397. /* validate and update open stateid and open seqid */
  2398. status = nfs4_preprocess_seqid_op(&cstate->current_fh,
  2399. lock->lk_new_open_seqid,
  2400. &lock->lk_new_open_stateid,
  2401. CHECK_FH | OPEN_STATE,
  2402. &lock->lk_replay_owner, &open_stp,
  2403. lock);
  2404. if (status)
  2405. goto out;
  2406. open_sop = lock->lk_replay_owner;
  2407. /* create lockowner and lock stateid */
  2408. fp = open_stp->st_file;
  2409. strhashval = lock_ownerstr_hashval(fp->fi_inode,
  2410. open_sop->so_client->cl_clientid.cl_id,
  2411. &lock->v.new.owner);
  2412. /* XXX: Do we need to check for duplicate stateowners on
  2413. * the same file, or should they just be allowed (and
  2414. * create new stateids)? */
  2415. status = nfserr_resource;
  2416. lock_sop = alloc_init_lock_stateowner(strhashval,
  2417. open_sop->so_client, open_stp, lock);
  2418. if (lock_sop == NULL)
  2419. goto out;
  2420. lock_stp = alloc_init_lock_stateid(lock_sop, fp, open_stp);
  2421. if (lock_stp == NULL)
  2422. goto out;
  2423. } else {
  2424. /* lock (lock owner + lock stateid) already exists */
  2425. status = nfs4_preprocess_seqid_op(&cstate->current_fh,
  2426. lock->lk_old_lock_seqid,
  2427. &lock->lk_old_lock_stateid,
  2428. CHECK_FH | LOCK_STATE,
  2429. &lock->lk_replay_owner, &lock_stp, lock);
  2430. if (status)
  2431. goto out;
  2432. lock_sop = lock->lk_replay_owner;
  2433. }
  2434. /* lock->lk_replay_owner and lock_stp have been created or found */
  2435. filp = lock_stp->st_vfs_file;
  2436. status = nfserr_grace;
  2437. if (nfs4_in_grace() && !lock->lk_reclaim)
  2438. goto out;
  2439. status = nfserr_no_grace;
  2440. if (!nfs4_in_grace() && lock->lk_reclaim)
  2441. goto out;
  2442. locks_init_lock(&file_lock);
  2443. switch (lock->lk_type) {
  2444. case NFS4_READ_LT:
  2445. case NFS4_READW_LT:
  2446. file_lock.fl_type = F_RDLCK;
  2447. break;
  2448. case NFS4_WRITE_LT:
  2449. case NFS4_WRITEW_LT:
  2450. file_lock.fl_type = F_WRLCK;
  2451. break;
  2452. default:
  2453. status = nfserr_inval;
  2454. goto out;
  2455. }
  2456. file_lock.fl_owner = (fl_owner_t)lock_sop;
  2457. file_lock.fl_pid = current->tgid;
  2458. file_lock.fl_file = filp;
  2459. file_lock.fl_flags = FL_POSIX;
  2460. file_lock.fl_lmops = &nfsd_posix_mng_ops;
  2461. file_lock.fl_start = lock->lk_offset;
  2462. if ((lock->lk_length == ~(u64)0) ||
  2463. LOFF_OVERFLOW(lock->lk_offset, lock->lk_length))
  2464. file_lock.fl_end = ~(u64)0;
  2465. else
  2466. file_lock.fl_end = lock->lk_offset + lock->lk_length - 1;
  2467. nfs4_transform_lock_offset(&file_lock);
  2468. /*
  2469. * Try to lock the file in the VFS.
  2470. * Note: locks.c uses the BKL to protect the inode's lock list.
  2471. */
  2472. /* XXX?: Just to divert the locks_release_private at the start of
  2473. * locks_copy_lock: */
  2474. conflock.fl_ops = NULL;
  2475. conflock.fl_lmops = NULL;
  2476. err = posix_lock_file_conf(filp, &file_lock, &conflock);
  2477. switch (-err) {
  2478. case 0: /* success! */
  2479. update_stateid(&lock_stp->st_stateid);
  2480. memcpy(&lock->lk_resp_stateid, &lock_stp->st_stateid,
  2481. sizeof(stateid_t));
  2482. status = 0;
  2483. break;
  2484. case (EAGAIN): /* conflock holds conflicting lock */
  2485. status = nfserr_denied;
  2486. dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
  2487. nfs4_set_lock_denied(&conflock, &lock->lk_denied);
  2488. break;
  2489. case (EDEADLK):
  2490. status = nfserr_deadlock;
  2491. break;
  2492. default:
  2493. dprintk("NFSD: nfsd4_lock: posix_lock_file_conf() failed! status %d\n",err);
  2494. status = nfserr_resource;
  2495. break;
  2496. }
  2497. out:
  2498. if (status && lock->lk_is_new && lock_sop)
  2499. release_stateowner(lock_sop);
  2500. if (lock->lk_replay_owner) {
  2501. nfs4_get_stateowner(lock->lk_replay_owner);
  2502. cstate->replay_owner = lock->lk_replay_owner;
  2503. }
  2504. nfs4_unlock_state();
  2505. return status;
  2506. }
  2507. /*
  2508. * LOCKT operation
  2509. */
  2510. __be32
  2511. nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
  2512. struct nfsd4_lockt *lockt)
  2513. {
  2514. struct inode *inode;
  2515. struct file file;
  2516. struct file_lock file_lock;
  2517. struct file_lock conflock;
  2518. __be32 status;
  2519. if (nfs4_in_grace())
  2520. return nfserr_grace;
  2521. if (check_lock_length(lockt->lt_offset, lockt->lt_length))
  2522. return nfserr_inval;
  2523. lockt->lt_stateowner = NULL;
  2524. nfs4_lock_state();
  2525. status = nfserr_stale_clientid;
  2526. if (STALE_CLIENTID(&lockt->lt_clientid))
  2527. goto out;
  2528. if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0))) {
  2529. dprintk("NFSD: nfsd4_lockt: fh_verify() failed!\n");
  2530. if (status == nfserr_symlink)
  2531. status = nfserr_inval;
  2532. goto out;
  2533. }
  2534. inode = cstate->current_fh.fh_dentry->d_inode;
  2535. locks_init_lock(&file_lock);
  2536. switch (lockt->lt_type) {
  2537. case NFS4_READ_LT:
  2538. case NFS4_READW_LT:
  2539. file_lock.fl_type = F_RDLCK;
  2540. break;
  2541. case NFS4_WRITE_LT:
  2542. case NFS4_WRITEW_LT:
  2543. file_lock.fl_type = F_WRLCK;
  2544. break;
  2545. default:
  2546. printk("NFSD: nfs4_lockt: bad lock type!\n");
  2547. status = nfserr_inval;
  2548. goto out;
  2549. }
  2550. lockt->lt_stateowner = find_lockstateowner_str(inode,
  2551. &lockt->lt_clientid, &lockt->lt_owner);
  2552. if (lockt->lt_stateowner)
  2553. file_lock.fl_owner = (fl_owner_t)lockt->lt_stateowner;
  2554. file_lock.fl_pid = current->tgid;
  2555. file_lock.fl_flags = FL_POSIX;
  2556. file_lock.fl_lmops = &nfsd_posix_mng_ops;
  2557. file_lock.fl_start = lockt->lt_offset;
  2558. if ((lockt->lt_length == ~(u64)0) || LOFF_OVERFLOW(lockt->lt_offset, lockt->lt_length))
  2559. file_lock.fl_end = ~(u64)0;
  2560. else
  2561. file_lock.fl_end = lockt->lt_offset + lockt->lt_length - 1;
  2562. nfs4_transform_lock_offset(&file_lock);
  2563. /* posix_test_lock uses the struct file _only_ to resolve the inode.
  2564. * since LOCKT doesn't require an OPEN, and therefore a struct
  2565. * file may not exist, pass posix_test_lock a struct file with
  2566. * only the dentry:inode set.
  2567. */
  2568. memset(&file, 0, sizeof (struct file));
  2569. file.f_path.dentry = cstate->current_fh.fh_dentry;
  2570. status = nfs_ok;
  2571. if (posix_test_lock(&file, &file_lock, &conflock)) {
  2572. status = nfserr_denied;
  2573. nfs4_set_lock_denied(&conflock, &lockt->lt_denied);
  2574. }
  2575. out:
  2576. nfs4_unlock_state();
  2577. return status;
  2578. }
  2579. __be32
  2580. nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
  2581. struct nfsd4_locku *locku)
  2582. {
  2583. struct nfs4_stateid *stp;
  2584. struct file *filp = NULL;
  2585. struct file_lock file_lock;
  2586. __be32 status;
  2587. int err;
  2588. dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
  2589. (long long) locku->lu_offset,
  2590. (long long) locku->lu_length);
  2591. if (check_lock_length(locku->lu_offset, locku->lu_length))
  2592. return nfserr_inval;
  2593. nfs4_lock_state();
  2594. if ((status = nfs4_preprocess_seqid_op(&cstate->current_fh,
  2595. locku->lu_seqid,
  2596. &locku->lu_stateid,
  2597. CHECK_FH | LOCK_STATE,
  2598. &locku->lu_stateowner, &stp, NULL)))
  2599. goto out;
  2600. filp = stp->st_vfs_file;
  2601. BUG_ON(!filp);
  2602. locks_init_lock(&file_lock);
  2603. file_lock.fl_type = F_UNLCK;
  2604. file_lock.fl_owner = (fl_owner_t) locku->lu_stateowner;
  2605. file_lock.fl_pid = current->tgid;
  2606. file_lock.fl_file = filp;
  2607. file_lock.fl_flags = FL_POSIX;
  2608. file_lock.fl_lmops = &nfsd_posix_mng_ops;
  2609. file_lock.fl_start = locku->lu_offset;
  2610. if ((locku->lu_length == ~(u64)0) || LOFF_OVERFLOW(locku->lu_offset, locku->lu_length))
  2611. file_lock.fl_end = ~(u64)0;
  2612. else
  2613. file_lock.fl_end = locku->lu_offset + locku->lu_length - 1;
  2614. nfs4_transform_lock_offset(&file_lock);
  2615. /*
  2616. * Try to unlock the file in the VFS.
  2617. */
  2618. err = posix_lock_file(filp, &file_lock);
  2619. if (err) {
  2620. dprintk("NFSD: nfs4_locku: posix_lock_file failed!\n");
  2621. goto out_nfserr;
  2622. }
  2623. /*
  2624. * OK, unlock succeeded; the only thing left to do is update the stateid.
  2625. */
  2626. update_stateid(&stp->st_stateid);
  2627. memcpy(&locku->lu_stateid, &stp->st_stateid, sizeof(stateid_t));
  2628. out:
  2629. if (locku->lu_stateowner) {
  2630. nfs4_get_stateowner(locku->lu_stateowner);
  2631. cstate->replay_owner = locku->lu_stateowner;
  2632. }
  2633. nfs4_unlock_state();
  2634. return status;
  2635. out_nfserr:
  2636. status = nfserrno(err);
  2637. goto out;
  2638. }
  2639. /*
  2640. * returns
  2641. * 1: locks held by lockowner
  2642. * 0: no locks held by lockowner
  2643. */
  2644. static int
  2645. check_for_locks(struct file *filp, struct nfs4_stateowner *lowner)
  2646. {
  2647. struct file_lock **flpp;
  2648. struct inode *inode = filp->f_path.dentry->d_inode;
  2649. int status = 0;
  2650. lock_kernel();
  2651. for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
  2652. if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
  2653. status = 1;
  2654. goto out;
  2655. }
  2656. }
  2657. out:
  2658. unlock_kernel();
  2659. return status;
  2660. }
  2661. __be32
  2662. nfsd4_release_lockowner(struct svc_rqst *rqstp,
  2663. struct nfsd4_compound_state *cstate,
  2664. struct nfsd4_release_lockowner *rlockowner)
  2665. {
  2666. clientid_t *clid = &rlockowner->rl_clientid;
  2667. struct nfs4_stateowner *sop;
  2668. struct nfs4_stateid *stp;
  2669. struct xdr_netobj *owner = &rlockowner->rl_owner;
  2670. struct list_head matches;
  2671. int i;
  2672. __be32 status;
  2673. dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
  2674. clid->cl_boot, clid->cl_id);
  2675. /* XXX check for lease expiration */
  2676. status = nfserr_stale_clientid;
  2677. if (STALE_CLIENTID(clid))
  2678. return status;
  2679. nfs4_lock_state();
  2680. status = nfserr_locks_held;
  2681. /* XXX: we're doing a linear search through all the lockowners.
  2682. * Yipes! For now we'll just hope clients aren't really using
  2683. * release_lockowner much, but eventually we have to fix these
  2684. * data structures. */
  2685. INIT_LIST_HEAD(&matches);
  2686. for (i = 0; i < LOCK_HASH_SIZE; i++) {
  2687. list_for_each_entry(sop, &lock_ownerid_hashtbl[i], so_idhash) {
  2688. if (!cmp_owner_str(sop, owner, clid))
  2689. continue;
  2690. list_for_each_entry(stp, &sop->so_stateids,
  2691. st_perstateowner) {
  2692. if (check_for_locks(stp->st_vfs_file, sop))
  2693. goto out;
  2694. /* Note: so_perclient unused for lockowners,
  2695. * so it's OK to fool with here. */
  2696. list_add(&sop->so_perclient, &matches);
  2697. }
  2698. }
  2699. }
  2700. /* Clients probably won't expect us to return with some (but not all)
  2701. * of the lockowner state released; so don't release any until all
  2702. * have been checked. */
  2703. status = nfs_ok;
  2704. while (!list_empty(&matches)) {
  2705. sop = list_entry(matches.next, struct nfs4_stateowner,
  2706. so_perclient);
  2707. /* unhash_stateowner deletes so_perclient only
  2708. * for openowners. */
  2709. list_del(&sop->so_perclient);
  2710. release_stateowner(sop);
  2711. }
  2712. out:
  2713. nfs4_unlock_state();
  2714. return status;
  2715. }
  2716. static inline struct nfs4_client_reclaim *
  2717. alloc_reclaim(void)
  2718. {
  2719. return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
  2720. }
  2721. int
  2722. nfs4_has_reclaimed_state(const char *name)
  2723. {
  2724. unsigned int strhashval = clientstr_hashval(name);
  2725. struct nfs4_client *clp;
  2726. clp = find_confirmed_client_by_str(name, strhashval);
  2727. return clp ? 1 : 0;
  2728. }
  2729. /*
  2730. * failure => all reset bets are off, nfserr_no_grace...
  2731. */
  2732. int
  2733. nfs4_client_to_reclaim(const char *name)
  2734. {
  2735. unsigned int strhashval;
  2736. struct nfs4_client_reclaim *crp = NULL;
  2737. dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
  2738. crp = alloc_reclaim();
  2739. if (!crp)
  2740. return 0;
  2741. strhashval = clientstr_hashval(name);
  2742. INIT_LIST_HEAD(&crp->cr_strhash);
  2743. list_add(&crp->cr_strhash, &reclaim_str_hashtbl[strhashval]);
  2744. memcpy(crp->cr_recdir, name, HEXDIR_LEN);
  2745. reclaim_str_hashtbl_size++;
  2746. return 1;
  2747. }
  2748. static void
  2749. nfs4_release_reclaim(void)
  2750. {
  2751. struct nfs4_client_reclaim *crp = NULL;
  2752. int i;
  2753. for (i = 0; i < CLIENT_HASH_SIZE; i++) {
  2754. while (!list_empty(&reclaim_str_hashtbl[i])) {
  2755. crp = list_entry(reclaim_str_hashtbl[i].next,
  2756. struct nfs4_client_reclaim, cr_strhash);
  2757. list_del(&crp->cr_strhash);
  2758. kfree(crp);
  2759. reclaim_str_hashtbl_size--;
  2760. }
  2761. }
  2762. BUG_ON(reclaim_str_hashtbl_size);
  2763. }
  2764. /*
  2765. * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
  2766. static struct nfs4_client_reclaim *
  2767. nfs4_find_reclaim_client(clientid_t *clid)
  2768. {
  2769. unsigned int strhashval;
  2770. struct nfs4_client *clp;
  2771. struct nfs4_client_reclaim *crp = NULL;
  2772. /* find clientid in conf_id_hashtbl */
  2773. clp = find_confirmed_client(clid);
  2774. if (clp == NULL)
  2775. return NULL;
  2776. dprintk("NFSD: nfs4_find_reclaim_client for %.*s with recdir %s\n",
  2777. clp->cl_name.len, clp->cl_name.data,
  2778. clp->cl_recdir);
  2779. /* find clp->cl_name in reclaim_str_hashtbl */
  2780. strhashval = clientstr_hashval(clp->cl_recdir);
  2781. list_for_each_entry(crp, &reclaim_str_hashtbl[strhashval], cr_strhash) {
  2782. if (same_name(crp->cr_recdir, clp->cl_recdir)) {
  2783. return crp;
  2784. }
  2785. }
  2786. return NULL;
  2787. }
  2788. /*
  2789. * Called from OPEN. Look for clientid in reclaim list.
  2790. */
  2791. __be32
  2792. nfs4_check_open_reclaim(clientid_t *clid)
  2793. {
  2794. return nfs4_find_reclaim_client(clid) ? nfs_ok : nfserr_reclaim_bad;
  2795. }
  2796. /* initialization to perform at module load time: */
  2797. void
  2798. nfs4_state_init(void)
  2799. {
  2800. int i;
  2801. for (i = 0; i < CLIENT_HASH_SIZE; i++) {
  2802. INIT_LIST_HEAD(&conf_id_hashtbl[i]);
  2803. INIT_LIST_HEAD(&conf_str_hashtbl[i]);
  2804. INIT_LIST_HEAD(&unconf_str_hashtbl[i]);
  2805. INIT_LIST_HEAD(&unconf_id_hashtbl[i]);
  2806. }
  2807. for (i = 0; i < FILE_HASH_SIZE; i++) {
  2808. INIT_LIST_HEAD(&file_hashtbl[i]);
  2809. }
  2810. for (i = 0; i < OWNER_HASH_SIZE; i++) {
  2811. INIT_LIST_HEAD(&ownerstr_hashtbl[i]);
  2812. INIT_LIST_HEAD(&ownerid_hashtbl[i]);
  2813. }
  2814. for (i = 0; i < STATEID_HASH_SIZE; i++) {
  2815. INIT_LIST_HEAD(&stateid_hashtbl[i]);
  2816. INIT_LIST_HEAD(&lockstateid_hashtbl[i]);
  2817. }
  2818. for (i = 0; i < LOCK_HASH_SIZE; i++) {
  2819. INIT_LIST_HEAD(&lock_ownerid_hashtbl[i]);
  2820. INIT_LIST_HEAD(&lock_ownerstr_hashtbl[i]);
  2821. }
  2822. memset(&onestateid, ~0, sizeof(stateid_t));
  2823. INIT_LIST_HEAD(&close_lru);
  2824. INIT_LIST_HEAD(&client_lru);
  2825. INIT_LIST_HEAD(&del_recall_lru);
  2826. for (i = 0; i < CLIENT_HASH_SIZE; i++)
  2827. INIT_LIST_HEAD(&reclaim_str_hashtbl[i]);
  2828. reclaim_str_hashtbl_size = 0;
  2829. }
  2830. static void
  2831. nfsd4_load_reboot_recovery_data(void)
  2832. {
  2833. int status;
  2834. nfs4_lock_state();
  2835. nfsd4_init_recdir(user_recovery_dirname);
  2836. status = nfsd4_recdir_load();
  2837. nfs4_unlock_state();
  2838. if (status)
  2839. printk("NFSD: Failure reading reboot recovery data\n");
  2840. }
  2841. /* initialization to perform when the nfsd service is started: */
  2842. static void
  2843. __nfs4_state_start(void)
  2844. {
  2845. time_t grace_time;
  2846. boot_time = get_seconds();
  2847. grace_time = max(user_lease_time, lease_time);
  2848. lease_time = user_lease_time;
  2849. in_grace = 1;
  2850. printk("NFSD: starting %ld-second grace period\n", grace_time);
  2851. laundry_wq = create_singlethread_workqueue("nfsd4");
  2852. queue_delayed_work(laundry_wq, &laundromat_work, grace_time*HZ);
  2853. }
  2854. int
  2855. nfs4_state_start(void)
  2856. {
  2857. int status;
  2858. if (nfs4_init)
  2859. return 0;
  2860. status = nfsd4_init_slabs();
  2861. if (status)
  2862. return status;
  2863. nfsd4_load_reboot_recovery_data();
  2864. __nfs4_state_start();
  2865. nfs4_init = 1;
  2866. return 0;
  2867. }
  2868. int
  2869. nfs4_in_grace(void)
  2870. {
  2871. return in_grace;
  2872. }
  2873. time_t
  2874. nfs4_lease_time(void)
  2875. {
  2876. return lease_time;
  2877. }
  2878. static void
  2879. __nfs4_state_shutdown(void)
  2880. {
  2881. int i;
  2882. struct nfs4_client *clp = NULL;
  2883. struct nfs4_delegation *dp = NULL;
  2884. struct list_head *pos, *next, reaplist;
  2885. for (i = 0; i < CLIENT_HASH_SIZE; i++) {
  2886. while (!list_empty(&conf_id_hashtbl[i])) {
  2887. clp = list_entry(conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
  2888. expire_client(clp);
  2889. }
  2890. while (!list_empty(&unconf_str_hashtbl[i])) {
  2891. clp = list_entry(unconf_str_hashtbl[i].next, struct nfs4_client, cl_strhash);
  2892. expire_client(clp);
  2893. }
  2894. }
  2895. INIT_LIST_HEAD(&reaplist);
  2896. spin_lock(&recall_lock);
  2897. list_for_each_safe(pos, next, &del_recall_lru) {
  2898. dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
  2899. list_move(&dp->dl_recall_lru, &reaplist);
  2900. }
  2901. spin_unlock(&recall_lock);
  2902. list_for_each_safe(pos, next, &reaplist) {
  2903. dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
  2904. list_del_init(&dp->dl_recall_lru);
  2905. unhash_delegation(dp);
  2906. }
  2907. nfsd4_shutdown_recdir();
  2908. nfs4_init = 0;
  2909. }
  2910. void
  2911. nfs4_state_shutdown(void)
  2912. {
  2913. cancel_rearming_delayed_workqueue(laundry_wq, &laundromat_work);
  2914. destroy_workqueue(laundry_wq);
  2915. nfs4_lock_state();
  2916. nfs4_release_reclaim();
  2917. __nfs4_state_shutdown();
  2918. nfsd4_free_slabs();
  2919. nfs4_unlock_state();
  2920. }
  2921. static void
  2922. nfs4_set_recdir(char *recdir)
  2923. {
  2924. nfs4_lock_state();
  2925. strcpy(user_recovery_dirname, recdir);
  2926. nfs4_unlock_state();
  2927. }
  2928. /*
  2929. * Change the NFSv4 recovery directory to recdir.
  2930. */
  2931. int
  2932. nfs4_reset_recoverydir(char *recdir)
  2933. {
  2934. int status;
  2935. struct nameidata nd;
  2936. status = path_lookup(recdir, LOOKUP_FOLLOW, &nd);
  2937. if (status)
  2938. return status;
  2939. status = -ENOTDIR;
  2940. if (S_ISDIR(nd.dentry->d_inode->i_mode)) {
  2941. nfs4_set_recdir(recdir);
  2942. status = 0;
  2943. }
  2944. path_release(&nd);
  2945. return status;
  2946. }
  2947. /*
  2948. * Called when leasetime is changed.
  2949. *
  2950. * The only way the protocol gives us to handle on-the-fly lease changes is to
  2951. * simulate a reboot. Instead of doing that, we just wait till the next time
  2952. * we start to register any changes in lease time. If the administrator
  2953. * really wants to change the lease time *now*, they can go ahead and bring
  2954. * nfsd down and then back up again after changing the lease time.
  2955. */
  2956. void
  2957. nfs4_reset_lease(time_t leasetime)
  2958. {
  2959. lock_kernel();
  2960. user_lease_time = leasetime;
  2961. unlock_kernel();
  2962. }