inode.c 35 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277
  1. /*
  2. * linux/fs/nfs/inode.c
  3. *
  4. * Copyright (C) 1992 Rick Sladkey
  5. *
  6. * nfs inode and superblock handling functions
  7. *
  8. * Modularised by Alan Cox <Alan.Cox@linux.org>, while hacking some
  9. * experimental NFS changes. Modularisation taken straight from SYS5 fs.
  10. *
  11. * Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
  12. * J.S.Peatfield@damtp.cam.ac.uk
  13. *
  14. */
  15. #include <linux/module.h>
  16. #include <linux/init.h>
  17. #include <linux/time.h>
  18. #include <linux/kernel.h>
  19. #include <linux/mm.h>
  20. #include <linux/string.h>
  21. #include <linux/stat.h>
  22. #include <linux/errno.h>
  23. #include <linux/unistd.h>
  24. #include <linux/sunrpc/clnt.h>
  25. #include <linux/sunrpc/stats.h>
  26. #include <linux/sunrpc/metrics.h>
  27. #include <linux/nfs_fs.h>
  28. #include <linux/nfs_mount.h>
  29. #include <linux/nfs4_mount.h>
  30. #include <linux/lockd/bind.h>
  31. #include <linux/smp_lock.h>
  32. #include <linux/seq_file.h>
  33. #include <linux/mount.h>
  34. #include <linux/nfs_idmap.h>
  35. #include <linux/vfs.h>
  36. #include <linux/inet.h>
  37. #include <linux/nfs_xdr.h>
  38. #include <asm/system.h>
  39. #include <asm/uaccess.h>
  40. #include "nfs4_fs.h"
  41. #include "callback.h"
  42. #include "delegation.h"
  43. #include "iostat.h"
  44. #include "internal.h"
  45. #define NFSDBG_FACILITY NFSDBG_VFS
  46. static void nfs_invalidate_inode(struct inode *);
  47. static int nfs_update_inode(struct inode *, struct nfs_fattr *);
  48. static void nfs_zap_acl_cache(struct inode *);
  49. static struct kmem_cache * nfs_inode_cachep;
  50. static inline unsigned long
  51. nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
  52. {
  53. return nfs_fileid_to_ino_t(fattr->fileid);
  54. }
  55. int nfs_write_inode(struct inode *inode, int sync)
  56. {
  57. int ret;
  58. if (sync) {
  59. ret = filemap_fdatawait(inode->i_mapping);
  60. if (ret == 0)
  61. ret = nfs_commit_inode(inode, FLUSH_SYNC);
  62. } else
  63. ret = nfs_commit_inode(inode, 0);
  64. if (ret >= 0)
  65. return 0;
  66. __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
  67. return ret;
  68. }
  69. void nfs_clear_inode(struct inode *inode)
  70. {
  71. /*
  72. * The following should never happen...
  73. */
  74. BUG_ON(nfs_have_writebacks(inode));
  75. BUG_ON(!list_empty(&NFS_I(inode)->open_files));
  76. BUG_ON(atomic_read(&NFS_I(inode)->data_updates) != 0);
  77. nfs_zap_acl_cache(inode);
  78. nfs_access_zap_cache(inode);
  79. }
  80. /**
  81. * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
  82. */
  83. int nfs_sync_mapping(struct address_space *mapping)
  84. {
  85. int ret;
  86. if (mapping->nrpages == 0)
  87. return 0;
  88. unmap_mapping_range(mapping, 0, 0, 0);
  89. ret = filemap_write_and_wait(mapping);
  90. if (ret != 0)
  91. goto out;
  92. ret = nfs_wb_all(mapping->host);
  93. out:
  94. return ret;
  95. }
  96. /*
  97. * Invalidate the local caches
  98. */
  99. static void nfs_zap_caches_locked(struct inode *inode)
  100. {
  101. struct nfs_inode *nfsi = NFS_I(inode);
  102. int mode = inode->i_mode;
  103. nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
  104. NFS_ATTRTIMEO(inode) = NFS_MINATTRTIMEO(inode);
  105. NFS_ATTRTIMEO_UPDATE(inode) = jiffies;
  106. memset(NFS_COOKIEVERF(inode), 0, sizeof(NFS_COOKIEVERF(inode)));
  107. if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))
  108. nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
  109. else
  110. nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
  111. }
  112. void nfs_zap_caches(struct inode *inode)
  113. {
  114. spin_lock(&inode->i_lock);
  115. nfs_zap_caches_locked(inode);
  116. spin_unlock(&inode->i_lock);
  117. }
  118. void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
  119. {
  120. if (mapping->nrpages != 0) {
  121. spin_lock(&inode->i_lock);
  122. NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
  123. spin_unlock(&inode->i_lock);
  124. }
  125. }
  126. static void nfs_zap_acl_cache(struct inode *inode)
  127. {
  128. void (*clear_acl_cache)(struct inode *);
  129. clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
  130. if (clear_acl_cache != NULL)
  131. clear_acl_cache(inode);
  132. spin_lock(&inode->i_lock);
  133. NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
  134. spin_unlock(&inode->i_lock);
  135. }
  136. /*
  137. * Invalidate, but do not unhash, the inode.
  138. * NB: must be called with inode->i_lock held!
  139. */
  140. static void nfs_invalidate_inode(struct inode *inode)
  141. {
  142. set_bit(NFS_INO_STALE, &NFS_FLAGS(inode));
  143. nfs_zap_caches_locked(inode);
  144. }
  145. struct nfs_find_desc {
  146. struct nfs_fh *fh;
  147. struct nfs_fattr *fattr;
  148. };
  149. /*
  150. * In NFSv3 we can have 64bit inode numbers. In order to support
  151. * this, and re-exported directories (also seen in NFSv2)
  152. * we are forced to allow 2 different inodes to have the same
  153. * i_ino.
  154. */
  155. static int
  156. nfs_find_actor(struct inode *inode, void *opaque)
  157. {
  158. struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
  159. struct nfs_fh *fh = desc->fh;
  160. struct nfs_fattr *fattr = desc->fattr;
  161. if (NFS_FILEID(inode) != fattr->fileid)
  162. return 0;
  163. if (nfs_compare_fh(NFS_FH(inode), fh))
  164. return 0;
  165. if (is_bad_inode(inode) || NFS_STALE(inode))
  166. return 0;
  167. return 1;
  168. }
  169. static int
  170. nfs_init_locked(struct inode *inode, void *opaque)
  171. {
  172. struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
  173. struct nfs_fattr *fattr = desc->fattr;
  174. NFS_FILEID(inode) = fattr->fileid;
  175. nfs_copy_fh(NFS_FH(inode), desc->fh);
  176. return 0;
  177. }
  178. /* Don't use READDIRPLUS on directories that we believe are too large */
  179. #define NFS_LIMIT_READDIRPLUS (8*PAGE_SIZE)
  180. /*
  181. * This is our front-end to iget that looks up inodes by file handle
  182. * instead of inode number.
  183. */
  184. struct inode *
  185. nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
  186. {
  187. struct nfs_find_desc desc = {
  188. .fh = fh,
  189. .fattr = fattr
  190. };
  191. struct inode *inode = ERR_PTR(-ENOENT);
  192. unsigned long hash;
  193. if ((fattr->valid & NFS_ATTR_FATTR) == 0)
  194. goto out_no_inode;
  195. if (!fattr->nlink) {
  196. printk("NFS: Buggy server - nlink == 0!\n");
  197. goto out_no_inode;
  198. }
  199. hash = nfs_fattr_to_ino_t(fattr);
  200. inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
  201. if (inode == NULL) {
  202. inode = ERR_PTR(-ENOMEM);
  203. goto out_no_inode;
  204. }
  205. if (inode->i_state & I_NEW) {
  206. struct nfs_inode *nfsi = NFS_I(inode);
  207. unsigned long now = jiffies;
  208. /* We set i_ino for the few things that still rely on it,
  209. * such as stat(2) */
  210. inode->i_ino = hash;
  211. /* We can't support update_atime(), since the server will reset it */
  212. inode->i_flags |= S_NOATIME|S_NOCMTIME;
  213. inode->i_mode = fattr->mode;
  214. /* Why so? Because we want revalidate for devices/FIFOs, and
  215. * that's precisely what we have in nfs_file_inode_operations.
  216. */
  217. inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
  218. if (S_ISREG(inode->i_mode)) {
  219. inode->i_fop = &nfs_file_operations;
  220. inode->i_data.a_ops = &nfs_file_aops;
  221. inode->i_data.backing_dev_info = &NFS_SB(sb)->backing_dev_info;
  222. } else if (S_ISDIR(inode->i_mode)) {
  223. inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
  224. inode->i_fop = &nfs_dir_operations;
  225. if (nfs_server_capable(inode, NFS_CAP_READDIRPLUS)
  226. && fattr->size <= NFS_LIMIT_READDIRPLUS)
  227. set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_FLAGS(inode));
  228. /* Deal with crossing mountpoints */
  229. if (!nfs_fsid_equal(&NFS_SB(sb)->fsid, &fattr->fsid)) {
  230. if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
  231. inode->i_op = &nfs_referral_inode_operations;
  232. else
  233. inode->i_op = &nfs_mountpoint_inode_operations;
  234. inode->i_fop = NULL;
  235. }
  236. } else if (S_ISLNK(inode->i_mode))
  237. inode->i_op = &nfs_symlink_inode_operations;
  238. else
  239. init_special_inode(inode, inode->i_mode, fattr->rdev);
  240. nfsi->read_cache_jiffies = fattr->time_start;
  241. nfsi->last_updated = now;
  242. nfsi->cache_change_attribute = now;
  243. inode->i_atime = fattr->atime;
  244. inode->i_mtime = fattr->mtime;
  245. inode->i_ctime = fattr->ctime;
  246. if (fattr->valid & NFS_ATTR_FATTR_V4)
  247. nfsi->change_attr = fattr->change_attr;
  248. inode->i_size = nfs_size_to_loff_t(fattr->size);
  249. inode->i_nlink = fattr->nlink;
  250. inode->i_uid = fattr->uid;
  251. inode->i_gid = fattr->gid;
  252. if (fattr->valid & (NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4)) {
  253. /*
  254. * report the blocks in 512byte units
  255. */
  256. inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
  257. } else {
  258. inode->i_blocks = fattr->du.nfs2.blocks;
  259. }
  260. nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
  261. nfsi->attrtimeo_timestamp = now;
  262. memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
  263. nfsi->access_cache = RB_ROOT;
  264. unlock_new_inode(inode);
  265. } else
  266. nfs_refresh_inode(inode, fattr);
  267. dprintk("NFS: nfs_fhget(%s/%Ld ct=%d)\n",
  268. inode->i_sb->s_id,
  269. (long long)NFS_FILEID(inode),
  270. atomic_read(&inode->i_count));
  271. out:
  272. return inode;
  273. out_no_inode:
  274. dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
  275. goto out;
  276. }
  277. #define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET)
  278. int
  279. nfs_setattr(struct dentry *dentry, struct iattr *attr)
  280. {
  281. struct inode *inode = dentry->d_inode;
  282. struct nfs_fattr fattr;
  283. int error;
  284. nfs_inc_stats(inode, NFSIOS_VFSSETATTR);
  285. if (attr->ia_valid & ATTR_SIZE) {
  286. if (!S_ISREG(inode->i_mode) || attr->ia_size == i_size_read(inode))
  287. attr->ia_valid &= ~ATTR_SIZE;
  288. }
  289. /* Optimization: if the end result is no change, don't RPC */
  290. attr->ia_valid &= NFS_VALID_ATTRS;
  291. if (attr->ia_valid == 0)
  292. return 0;
  293. lock_kernel();
  294. nfs_begin_data_update(inode);
  295. /* Write all dirty data */
  296. if (S_ISREG(inode->i_mode)) {
  297. filemap_write_and_wait(inode->i_mapping);
  298. nfs_wb_all(inode);
  299. }
  300. /*
  301. * Return any delegations if we're going to change ACLs
  302. */
  303. if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0)
  304. nfs_inode_return_delegation(inode);
  305. error = NFS_PROTO(inode)->setattr(dentry, &fattr, attr);
  306. if (error == 0)
  307. nfs_refresh_inode(inode, &fattr);
  308. nfs_end_data_update(inode);
  309. unlock_kernel();
  310. return error;
  311. }
  312. /**
  313. * nfs_setattr_update_inode - Update inode metadata after a setattr call.
  314. * @inode: pointer to struct inode
  315. * @attr: pointer to struct iattr
  316. *
  317. * Note: we do this in the *proc.c in order to ensure that
  318. * it works for things like exclusive creates too.
  319. */
  320. void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr)
  321. {
  322. if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) {
  323. if ((attr->ia_valid & ATTR_MODE) != 0) {
  324. int mode = attr->ia_mode & S_IALLUGO;
  325. mode |= inode->i_mode & ~S_IALLUGO;
  326. inode->i_mode = mode;
  327. }
  328. if ((attr->ia_valid & ATTR_UID) != 0)
  329. inode->i_uid = attr->ia_uid;
  330. if ((attr->ia_valid & ATTR_GID) != 0)
  331. inode->i_gid = attr->ia_gid;
  332. spin_lock(&inode->i_lock);
  333. NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
  334. spin_unlock(&inode->i_lock);
  335. }
  336. if ((attr->ia_valid & ATTR_SIZE) != 0) {
  337. nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
  338. inode->i_size = attr->ia_size;
  339. vmtruncate(inode, attr->ia_size);
  340. }
  341. }
  342. static int nfs_wait_schedule(void *word)
  343. {
  344. if (signal_pending(current))
  345. return -ERESTARTSYS;
  346. schedule();
  347. return 0;
  348. }
  349. /*
  350. * Wait for the inode to get unlocked.
  351. */
  352. static int nfs_wait_on_inode(struct inode *inode)
  353. {
  354. struct rpc_clnt *clnt = NFS_CLIENT(inode);
  355. struct nfs_inode *nfsi = NFS_I(inode);
  356. sigset_t oldmask;
  357. int error;
  358. rpc_clnt_sigmask(clnt, &oldmask);
  359. error = wait_on_bit_lock(&nfsi->flags, NFS_INO_REVALIDATING,
  360. nfs_wait_schedule, TASK_INTERRUPTIBLE);
  361. rpc_clnt_sigunmask(clnt, &oldmask);
  362. return error;
  363. }
  364. static void nfs_wake_up_inode(struct inode *inode)
  365. {
  366. struct nfs_inode *nfsi = NFS_I(inode);
  367. clear_bit(NFS_INO_REVALIDATING, &nfsi->flags);
  368. smp_mb__after_clear_bit();
  369. wake_up_bit(&nfsi->flags, NFS_INO_REVALIDATING);
  370. }
  371. int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
  372. {
  373. struct inode *inode = dentry->d_inode;
  374. int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
  375. int err;
  376. /* Flush out writes to the server in order to update c/mtime */
  377. if (S_ISREG(inode->i_mode))
  378. nfs_sync_mapping_range(inode->i_mapping, 0, 0, FLUSH_NOCOMMIT);
  379. /*
  380. * We may force a getattr if the user cares about atime.
  381. *
  382. * Note that we only have to check the vfsmount flags here:
  383. * - NFS always sets S_NOATIME by so checking it would give a
  384. * bogus result
  385. * - NFS never sets MS_NOATIME or MS_NODIRATIME so there is
  386. * no point in checking those.
  387. */
  388. if ((mnt->mnt_flags & MNT_NOATIME) ||
  389. ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
  390. need_atime = 0;
  391. if (need_atime)
  392. err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
  393. else
  394. err = nfs_revalidate_inode(NFS_SERVER(inode), inode);
  395. if (!err)
  396. generic_fillattr(inode, stat);
  397. return err;
  398. }
  399. static struct nfs_open_context *alloc_nfs_open_context(struct vfsmount *mnt, struct dentry *dentry, struct rpc_cred *cred)
  400. {
  401. struct nfs_open_context *ctx;
  402. ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
  403. if (ctx != NULL) {
  404. atomic_set(&ctx->count, 1);
  405. ctx->dentry = dget(dentry);
  406. ctx->vfsmnt = mntget(mnt);
  407. ctx->cred = get_rpccred(cred);
  408. ctx->state = NULL;
  409. ctx->lockowner = current->files;
  410. ctx->error = 0;
  411. ctx->dir_cookie = 0;
  412. }
  413. return ctx;
  414. }
  415. struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
  416. {
  417. if (ctx != NULL)
  418. atomic_inc(&ctx->count);
  419. return ctx;
  420. }
  421. void put_nfs_open_context(struct nfs_open_context *ctx)
  422. {
  423. if (atomic_dec_and_test(&ctx->count)) {
  424. if (!list_empty(&ctx->list)) {
  425. struct inode *inode = ctx->dentry->d_inode;
  426. spin_lock(&inode->i_lock);
  427. list_del(&ctx->list);
  428. spin_unlock(&inode->i_lock);
  429. }
  430. if (ctx->state != NULL)
  431. nfs4_close_state(ctx->state, ctx->mode);
  432. if (ctx->cred != NULL)
  433. put_rpccred(ctx->cred);
  434. dput(ctx->dentry);
  435. mntput(ctx->vfsmnt);
  436. kfree(ctx);
  437. }
  438. }
  439. /*
  440. * Ensure that mmap has a recent RPC credential for use when writing out
  441. * shared pages
  442. */
  443. static void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
  444. {
  445. struct inode *inode = filp->f_path.dentry->d_inode;
  446. struct nfs_inode *nfsi = NFS_I(inode);
  447. filp->private_data = get_nfs_open_context(ctx);
  448. spin_lock(&inode->i_lock);
  449. list_add(&ctx->list, &nfsi->open_files);
  450. spin_unlock(&inode->i_lock);
  451. }
  452. /*
  453. * Given an inode, search for an open context with the desired characteristics
  454. */
  455. struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, int mode)
  456. {
  457. struct nfs_inode *nfsi = NFS_I(inode);
  458. struct nfs_open_context *pos, *ctx = NULL;
  459. spin_lock(&inode->i_lock);
  460. list_for_each_entry(pos, &nfsi->open_files, list) {
  461. if (cred != NULL && pos->cred != cred)
  462. continue;
  463. if ((pos->mode & mode) == mode) {
  464. ctx = get_nfs_open_context(pos);
  465. break;
  466. }
  467. }
  468. spin_unlock(&inode->i_lock);
  469. return ctx;
  470. }
  471. static void nfs_file_clear_open_context(struct file *filp)
  472. {
  473. struct inode *inode = filp->f_path.dentry->d_inode;
  474. struct nfs_open_context *ctx = (struct nfs_open_context *)filp->private_data;
  475. if (ctx) {
  476. filp->private_data = NULL;
  477. spin_lock(&inode->i_lock);
  478. list_move_tail(&ctx->list, &NFS_I(inode)->open_files);
  479. spin_unlock(&inode->i_lock);
  480. put_nfs_open_context(ctx);
  481. }
  482. }
  483. /*
  484. * These allocate and release file read/write context information.
  485. */
  486. int nfs_open(struct inode *inode, struct file *filp)
  487. {
  488. struct nfs_open_context *ctx;
  489. struct rpc_cred *cred;
  490. cred = rpcauth_lookupcred(NFS_CLIENT(inode)->cl_auth, 0);
  491. if (IS_ERR(cred))
  492. return PTR_ERR(cred);
  493. ctx = alloc_nfs_open_context(filp->f_path.mnt, filp->f_path.dentry, cred);
  494. put_rpccred(cred);
  495. if (ctx == NULL)
  496. return -ENOMEM;
  497. ctx->mode = filp->f_mode;
  498. nfs_file_set_open_context(filp, ctx);
  499. put_nfs_open_context(ctx);
  500. return 0;
  501. }
  502. int nfs_release(struct inode *inode, struct file *filp)
  503. {
  504. nfs_file_clear_open_context(filp);
  505. return 0;
  506. }
  507. /*
  508. * This function is called whenever some part of NFS notices that
  509. * the cached attributes have to be refreshed.
  510. */
  511. int
  512. __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
  513. {
  514. int status = -ESTALE;
  515. struct nfs_fattr fattr;
  516. struct nfs_inode *nfsi = NFS_I(inode);
  517. dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n",
  518. inode->i_sb->s_id, (long long)NFS_FILEID(inode));
  519. nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
  520. lock_kernel();
  521. if (is_bad_inode(inode))
  522. goto out_nowait;
  523. if (NFS_STALE(inode))
  524. goto out_nowait;
  525. status = nfs_wait_on_inode(inode);
  526. if (status < 0)
  527. goto out;
  528. if (NFS_STALE(inode)) {
  529. status = -ESTALE;
  530. /* Do we trust the cached ESTALE? */
  531. if (NFS_ATTRTIMEO(inode) != 0) {
  532. if (nfsi->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ATIME)) {
  533. /* no */
  534. } else
  535. goto out;
  536. }
  537. }
  538. status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), &fattr);
  539. if (status != 0) {
  540. dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n",
  541. inode->i_sb->s_id,
  542. (long long)NFS_FILEID(inode), status);
  543. if (status == -ESTALE) {
  544. nfs_zap_caches(inode);
  545. if (!S_ISDIR(inode->i_mode))
  546. set_bit(NFS_INO_STALE, &NFS_FLAGS(inode));
  547. }
  548. goto out;
  549. }
  550. spin_lock(&inode->i_lock);
  551. status = nfs_update_inode(inode, &fattr);
  552. if (status) {
  553. spin_unlock(&inode->i_lock);
  554. dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n",
  555. inode->i_sb->s_id,
  556. (long long)NFS_FILEID(inode), status);
  557. goto out;
  558. }
  559. spin_unlock(&inode->i_lock);
  560. if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
  561. nfs_zap_acl_cache(inode);
  562. dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n",
  563. inode->i_sb->s_id,
  564. (long long)NFS_FILEID(inode));
  565. out:
  566. nfs_wake_up_inode(inode);
  567. out_nowait:
  568. unlock_kernel();
  569. return status;
  570. }
  571. int nfs_attribute_timeout(struct inode *inode)
  572. {
  573. struct nfs_inode *nfsi = NFS_I(inode);
  574. if (nfs_have_delegation(inode, FMODE_READ))
  575. return 0;
  576. return time_after(jiffies, nfsi->read_cache_jiffies+nfsi->attrtimeo);
  577. }
  578. /**
  579. * nfs_revalidate_inode - Revalidate the inode attributes
  580. * @server - pointer to nfs_server struct
  581. * @inode - pointer to inode struct
  582. *
  583. * Updates inode attribute information by retrieving the data from the server.
  584. */
  585. int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
  586. {
  587. if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR)
  588. && !nfs_attribute_timeout(inode))
  589. return NFS_STALE(inode) ? -ESTALE : 0;
  590. return __nfs_revalidate_inode(server, inode);
  591. }
  592. static int nfs_invalidate_mapping_nolock(struct inode *inode, struct address_space *mapping)
  593. {
  594. struct nfs_inode *nfsi = NFS_I(inode);
  595. if (mapping->nrpages != 0) {
  596. int ret = invalidate_inode_pages2(mapping);
  597. if (ret < 0)
  598. return ret;
  599. }
  600. spin_lock(&inode->i_lock);
  601. nfsi->cache_validity &= ~NFS_INO_INVALID_DATA;
  602. if (S_ISDIR(inode->i_mode)) {
  603. memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
  604. /* This ensures we revalidate child dentries */
  605. nfsi->cache_change_attribute = jiffies;
  606. }
  607. spin_unlock(&inode->i_lock);
  608. nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
  609. dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n",
  610. inode->i_sb->s_id, (long long)NFS_FILEID(inode));
  611. return 0;
  612. }
  613. static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
  614. {
  615. int ret = 0;
  616. mutex_lock(&inode->i_mutex);
  617. if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_DATA) {
  618. ret = nfs_sync_mapping(mapping);
  619. if (ret == 0)
  620. ret = nfs_invalidate_mapping_nolock(inode, mapping);
  621. }
  622. mutex_unlock(&inode->i_mutex);
  623. return ret;
  624. }
  625. /**
  626. * nfs_revalidate_mapping_nolock - Revalidate the pagecache
  627. * @inode - pointer to host inode
  628. * @mapping - pointer to mapping
  629. */
  630. int nfs_revalidate_mapping_nolock(struct inode *inode, struct address_space *mapping)
  631. {
  632. struct nfs_inode *nfsi = NFS_I(inode);
  633. int ret = 0;
  634. if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
  635. || nfs_attribute_timeout(inode) || NFS_STALE(inode)) {
  636. ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
  637. if (ret < 0)
  638. goto out;
  639. }
  640. if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
  641. ret = nfs_invalidate_mapping_nolock(inode, mapping);
  642. out:
  643. return ret;
  644. }
  645. /**
  646. * nfs_revalidate_mapping - Revalidate the pagecache
  647. * @inode - pointer to host inode
  648. * @mapping - pointer to mapping
  649. *
  650. * This version of the function will take the inode->i_mutex and attempt to
  651. * flush out all dirty data if it needs to invalidate the page cache.
  652. */
  653. int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
  654. {
  655. struct nfs_inode *nfsi = NFS_I(inode);
  656. int ret = 0;
  657. if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
  658. || nfs_attribute_timeout(inode) || NFS_STALE(inode)) {
  659. ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
  660. if (ret < 0)
  661. goto out;
  662. }
  663. if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
  664. ret = nfs_invalidate_mapping(inode, mapping);
  665. out:
  666. return ret;
  667. }
  668. /**
  669. * nfs_begin_data_update
  670. * @inode - pointer to inode
  671. * Declare that a set of operations will update file data on the server
  672. */
  673. void nfs_begin_data_update(struct inode *inode)
  674. {
  675. atomic_inc(&NFS_I(inode)->data_updates);
  676. }
  677. /**
  678. * nfs_end_data_update
  679. * @inode - pointer to inode
  680. * Declare end of the operations that will update file data
  681. * This will mark the inode as immediately needing revalidation
  682. * of its attribute cache.
  683. */
  684. void nfs_end_data_update(struct inode *inode)
  685. {
  686. struct nfs_inode *nfsi = NFS_I(inode);
  687. /* Directories: invalidate page cache */
  688. if (S_ISDIR(inode->i_mode)) {
  689. spin_lock(&inode->i_lock);
  690. nfsi->cache_validity |= NFS_INO_INVALID_DATA;
  691. spin_unlock(&inode->i_lock);
  692. }
  693. nfsi->cache_change_attribute = jiffies;
  694. atomic_dec(&nfsi->data_updates);
  695. }
  696. static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
  697. {
  698. struct nfs_inode *nfsi = NFS_I(inode);
  699. unsigned long now = jiffies;
  700. /* If we have atomic WCC data, we may update some attributes */
  701. if ((fattr->valid & NFS_ATTR_WCC) != 0) {
  702. if (timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) {
  703. memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
  704. nfsi->cache_change_attribute = now;
  705. }
  706. if (timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) {
  707. memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
  708. nfsi->cache_change_attribute = now;
  709. }
  710. if (inode->i_size == fattr->pre_size && nfsi->npages == 0) {
  711. inode->i_size = fattr->size;
  712. nfsi->cache_change_attribute = now;
  713. }
  714. }
  715. }
  716. /**
  717. * nfs_check_inode_attributes - verify consistency of the inode attribute cache
  718. * @inode - pointer to inode
  719. * @fattr - updated attributes
  720. *
  721. * Verifies the attribute cache. If we have just changed the attributes,
  722. * so that fattr carries weak cache consistency data, then it may
  723. * also update the ctime/mtime/change_attribute.
  724. */
  725. static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
  726. {
  727. struct nfs_inode *nfsi = NFS_I(inode);
  728. loff_t cur_size, new_isize;
  729. int data_unstable;
  730. /* Has the inode gone and changed behind our back? */
  731. if (nfsi->fileid != fattr->fileid
  732. || (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) {
  733. return -EIO;
  734. }
  735. /* Are we in the process of updating data on the server? */
  736. data_unstable = nfs_caches_unstable(inode);
  737. /* Do atomic weak cache consistency updates */
  738. nfs_wcc_update_inode(inode, fattr);
  739. if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 &&
  740. nfsi->change_attr != fattr->change_attr)
  741. nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
  742. /* Verify a few of the more important attributes */
  743. if (!timespec_equal(&inode->i_mtime, &fattr->mtime))
  744. nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
  745. cur_size = i_size_read(inode);
  746. new_isize = nfs_size_to_loff_t(fattr->size);
  747. if (cur_size != new_isize && nfsi->npages == 0)
  748. nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
  749. /* Have any file permissions changed? */
  750. if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)
  751. || inode->i_uid != fattr->uid
  752. || inode->i_gid != fattr->gid)
  753. nfsi->cache_validity |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
  754. /* Has the link count changed? */
  755. if (inode->i_nlink != fattr->nlink)
  756. nfsi->cache_validity |= NFS_INO_INVALID_ATTR;
  757. if (!timespec_equal(&inode->i_atime, &fattr->atime))
  758. nfsi->cache_validity |= NFS_INO_INVALID_ATIME;
  759. nfsi->read_cache_jiffies = fattr->time_start;
  760. return 0;
  761. }
  762. /**
  763. * nfs_refresh_inode - try to update the inode attribute cache
  764. * @inode - pointer to inode
  765. * @fattr - updated attributes
  766. *
  767. * Check that an RPC call that returned attributes has not overlapped with
  768. * other recent updates of the inode metadata, then decide whether it is
  769. * safe to do a full update of the inode attributes, or whether just to
  770. * call nfs_check_inode_attributes.
  771. */
  772. int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
  773. {
  774. struct nfs_inode *nfsi = NFS_I(inode);
  775. int status;
  776. if ((fattr->valid & NFS_ATTR_FATTR) == 0)
  777. return 0;
  778. spin_lock(&inode->i_lock);
  779. if (time_after(fattr->time_start, nfsi->last_updated))
  780. status = nfs_update_inode(inode, fattr);
  781. else
  782. status = nfs_check_inode_attributes(inode, fattr);
  783. spin_unlock(&inode->i_lock);
  784. return status;
  785. }
  786. /**
  787. * nfs_post_op_update_inode - try to update the inode attribute cache
  788. * @inode - pointer to inode
  789. * @fattr - updated attributes
  790. *
  791. * After an operation that has changed the inode metadata, mark the
  792. * attribute cache as being invalid, then try to update it.
  793. *
  794. * NB: if the server didn't return any post op attributes, this
  795. * function will force the retrieval of attributes before the next
  796. * NFS request. Thus it should be used only for operations that
  797. * are expected to change one or more attributes, to avoid
  798. * unnecessary NFS requests and trips through nfs_update_inode().
  799. */
  800. int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
  801. {
  802. struct nfs_inode *nfsi = NFS_I(inode);
  803. int status = 0;
  804. spin_lock(&inode->i_lock);
  805. if (unlikely((fattr->valid & NFS_ATTR_FATTR) == 0)) {
  806. nfsi->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
  807. goto out;
  808. }
  809. status = nfs_update_inode(inode, fattr);
  810. out:
  811. spin_unlock(&inode->i_lock);
  812. return status;
  813. }
  814. /*
  815. * Many nfs protocol calls return the new file attributes after
  816. * an operation. Here we update the inode to reflect the state
  817. * of the server's inode.
  818. *
  819. * This is a bit tricky because we have to make sure all dirty pages
  820. * have been sent off to the server before calling invalidate_inode_pages.
  821. * To make sure no other process adds more write requests while we try
  822. * our best to flush them, we make them sleep during the attribute refresh.
  823. *
  824. * A very similar scenario holds for the dir cache.
  825. */
  826. static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
  827. {
  828. struct nfs_server *server;
  829. struct nfs_inode *nfsi = NFS_I(inode);
  830. loff_t cur_isize, new_isize;
  831. unsigned int invalid = 0;
  832. unsigned long now = jiffies;
  833. int data_stable;
  834. dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n",
  835. __FUNCTION__, inode->i_sb->s_id, inode->i_ino,
  836. atomic_read(&inode->i_count), fattr->valid);
  837. if (nfsi->fileid != fattr->fileid)
  838. goto out_fileid;
  839. /*
  840. * Make sure the inode's type hasn't changed.
  841. */
  842. if ((inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
  843. goto out_changed;
  844. server = NFS_SERVER(inode);
  845. /* Update the fsid if and only if this is the root directory */
  846. if (inode == inode->i_sb->s_root->d_inode
  847. && !nfs_fsid_equal(&server->fsid, &fattr->fsid))
  848. server->fsid = fattr->fsid;
  849. /*
  850. * Update the read time so we don't revalidate too often.
  851. */
  852. nfsi->read_cache_jiffies = fattr->time_start;
  853. nfsi->last_updated = now;
  854. /* Fix a wraparound issue with nfsi->cache_change_attribute */
  855. if (time_before(now, nfsi->cache_change_attribute))
  856. nfsi->cache_change_attribute = now - 600*HZ;
  857. /* Are we racing with known updates of the metadata on the server? */
  858. data_stable = nfs_verify_change_attribute(inode, fattr->time_start);
  859. if (data_stable)
  860. nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_ATIME);
  861. /* Do atomic weak cache consistency updates */
  862. nfs_wcc_update_inode(inode, fattr);
  863. /* Check if our cached file size is stale */
  864. new_isize = nfs_size_to_loff_t(fattr->size);
  865. cur_isize = i_size_read(inode);
  866. if (new_isize != cur_isize) {
  867. /* Do we perhaps have any outstanding writes? */
  868. if (nfsi->npages == 0) {
  869. /* No, but did we race with nfs_end_data_update()? */
  870. if (data_stable) {
  871. inode->i_size = new_isize;
  872. invalid |= NFS_INO_INVALID_DATA;
  873. }
  874. invalid |= NFS_INO_INVALID_ATTR;
  875. } else if (new_isize > cur_isize) {
  876. inode->i_size = new_isize;
  877. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
  878. }
  879. nfsi->cache_change_attribute = now;
  880. dprintk("NFS: isize change on server for file %s/%ld\n",
  881. inode->i_sb->s_id, inode->i_ino);
  882. }
  883. /* Check if the mtime agrees */
  884. if (!timespec_equal(&inode->i_mtime, &fattr->mtime)) {
  885. memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
  886. dprintk("NFS: mtime change on server for file %s/%ld\n",
  887. inode->i_sb->s_id, inode->i_ino);
  888. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
  889. nfsi->cache_change_attribute = now;
  890. }
  891. /* If ctime has changed we should definitely clear access+acl caches */
  892. if (!timespec_equal(&inode->i_ctime, &fattr->ctime)) {
  893. invalid |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
  894. memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
  895. nfsi->cache_change_attribute = now;
  896. }
  897. memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));
  898. if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO) ||
  899. inode->i_uid != fattr->uid ||
  900. inode->i_gid != fattr->gid)
  901. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
  902. inode->i_mode = fattr->mode;
  903. inode->i_nlink = fattr->nlink;
  904. inode->i_uid = fattr->uid;
  905. inode->i_gid = fattr->gid;
  906. if (fattr->valid & (NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4)) {
  907. /*
  908. * report the blocks in 512byte units
  909. */
  910. inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
  911. } else {
  912. inode->i_blocks = fattr->du.nfs2.blocks;
  913. }
  914. if ((fattr->valid & NFS_ATTR_FATTR_V4) != 0 &&
  915. nfsi->change_attr != fattr->change_attr) {
  916. dprintk("NFS: change_attr change on server for file %s/%ld\n",
  917. inode->i_sb->s_id, inode->i_ino);
  918. nfsi->change_attr = fattr->change_attr;
  919. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
  920. nfsi->cache_change_attribute = now;
  921. }
  922. /* Update attrtimeo value if we're out of the unstable period */
  923. if (invalid & NFS_INO_INVALID_ATTR) {
  924. nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
  925. nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
  926. nfsi->attrtimeo_timestamp = now;
  927. } else if (time_after(now, nfsi->attrtimeo_timestamp+nfsi->attrtimeo)) {
  928. if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))
  929. nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
  930. nfsi->attrtimeo_timestamp = now;
  931. }
  932. /* Don't invalidate the data if we were to blame */
  933. if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
  934. || S_ISLNK(inode->i_mode)))
  935. invalid &= ~NFS_INO_INVALID_DATA;
  936. if (data_stable)
  937. invalid &= ~(NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ATIME|NFS_INO_REVAL_PAGECACHE);
  938. if (!nfs_have_delegation(inode, FMODE_READ))
  939. nfsi->cache_validity |= invalid;
  940. return 0;
  941. out_changed:
  942. /*
  943. * Big trouble! The inode has become a different object.
  944. */
  945. printk(KERN_DEBUG "%s: inode %ld mode changed, %07o to %07o\n",
  946. __FUNCTION__, inode->i_ino, inode->i_mode, fattr->mode);
  947. out_err:
  948. /*
  949. * No need to worry about unhashing the dentry, as the
  950. * lookup validation will know that the inode is bad.
  951. * (But we fall through to invalidate the caches.)
  952. */
  953. nfs_invalidate_inode(inode);
  954. return -ESTALE;
  955. out_fileid:
  956. printk(KERN_ERR "NFS: server %s error: fileid changed\n"
  957. "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
  958. NFS_SERVER(inode)->nfs_client->cl_hostname, inode->i_sb->s_id,
  959. (long long)nfsi->fileid, (long long)fattr->fileid);
  960. goto out_err;
  961. }
  962. #ifdef CONFIG_NFS_V4
  963. /*
  964. * Clean out any remaining NFSv4 state that might be left over due
  965. * to open() calls that passed nfs_atomic_lookup, but failed to call
  966. * nfs_open().
  967. */
  968. void nfs4_clear_inode(struct inode *inode)
  969. {
  970. struct nfs_inode *nfsi = NFS_I(inode);
  971. /* If we are holding a delegation, return it! */
  972. nfs_inode_return_delegation(inode);
  973. /* First call standard NFS clear_inode() code */
  974. nfs_clear_inode(inode);
  975. /* Now clear out any remaining state */
  976. while (!list_empty(&nfsi->open_states)) {
  977. struct nfs4_state *state;
  978. state = list_entry(nfsi->open_states.next,
  979. struct nfs4_state,
  980. inode_states);
  981. dprintk("%s(%s/%Ld): found unclaimed NFSv4 state %p\n",
  982. __FUNCTION__,
  983. inode->i_sb->s_id,
  984. (long long)NFS_FILEID(inode),
  985. state);
  986. BUG_ON(atomic_read(&state->count) != 1);
  987. nfs4_close_state(state, state->state);
  988. }
  989. }
  990. #endif
  991. struct inode *nfs_alloc_inode(struct super_block *sb)
  992. {
  993. struct nfs_inode *nfsi;
  994. nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
  995. if (!nfsi)
  996. return NULL;
  997. nfsi->flags = 0UL;
  998. nfsi->cache_validity = 0UL;
  999. #ifdef CONFIG_NFS_V3_ACL
  1000. nfsi->acl_access = ERR_PTR(-EAGAIN);
  1001. nfsi->acl_default = ERR_PTR(-EAGAIN);
  1002. #endif
  1003. #ifdef CONFIG_NFS_V4
  1004. nfsi->nfs4_acl = NULL;
  1005. #endif /* CONFIG_NFS_V4 */
  1006. return &nfsi->vfs_inode;
  1007. }
  1008. void nfs_destroy_inode(struct inode *inode)
  1009. {
  1010. kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
  1011. }
  1012. static inline void nfs4_init_once(struct nfs_inode *nfsi)
  1013. {
  1014. #ifdef CONFIG_NFS_V4
  1015. INIT_LIST_HEAD(&nfsi->open_states);
  1016. nfsi->delegation = NULL;
  1017. nfsi->delegation_state = 0;
  1018. init_rwsem(&nfsi->rwsem);
  1019. #endif
  1020. }
  1021. static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
  1022. {
  1023. struct nfs_inode *nfsi = (struct nfs_inode *) foo;
  1024. if (flags & SLAB_CTOR_CONSTRUCTOR) {
  1025. inode_init_once(&nfsi->vfs_inode);
  1026. spin_lock_init(&nfsi->req_lock);
  1027. INIT_LIST_HEAD(&nfsi->dirty);
  1028. INIT_LIST_HEAD(&nfsi->commit);
  1029. INIT_LIST_HEAD(&nfsi->open_files);
  1030. INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
  1031. INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
  1032. INIT_RADIX_TREE(&nfsi->nfs_page_tree, GFP_ATOMIC);
  1033. atomic_set(&nfsi->data_updates, 0);
  1034. nfsi->ndirty = 0;
  1035. nfsi->ncommit = 0;
  1036. nfsi->npages = 0;
  1037. nfs4_init_once(nfsi);
  1038. }
  1039. }
  1040. static int __init nfs_init_inodecache(void)
  1041. {
  1042. nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
  1043. sizeof(struct nfs_inode),
  1044. 0, (SLAB_RECLAIM_ACCOUNT|
  1045. SLAB_MEM_SPREAD),
  1046. init_once, NULL);
  1047. if (nfs_inode_cachep == NULL)
  1048. return -ENOMEM;
  1049. return 0;
  1050. }
  1051. static void nfs_destroy_inodecache(void)
  1052. {
  1053. kmem_cache_destroy(nfs_inode_cachep);
  1054. }
  1055. /*
  1056. * Initialize NFS
  1057. */
  1058. static int __init init_nfs_fs(void)
  1059. {
  1060. int err;
  1061. err = nfs_fs_proc_init();
  1062. if (err)
  1063. goto out5;
  1064. err = nfs_init_nfspagecache();
  1065. if (err)
  1066. goto out4;
  1067. err = nfs_init_inodecache();
  1068. if (err)
  1069. goto out3;
  1070. err = nfs_init_readpagecache();
  1071. if (err)
  1072. goto out2;
  1073. err = nfs_init_writepagecache();
  1074. if (err)
  1075. goto out1;
  1076. err = nfs_init_directcache();
  1077. if (err)
  1078. goto out0;
  1079. #ifdef CONFIG_PROC_FS
  1080. rpc_proc_register(&nfs_rpcstat);
  1081. #endif
  1082. if ((err = register_nfs_fs()) != 0)
  1083. goto out;
  1084. return 0;
  1085. out:
  1086. #ifdef CONFIG_PROC_FS
  1087. rpc_proc_unregister("nfs");
  1088. #endif
  1089. nfs_destroy_directcache();
  1090. out0:
  1091. nfs_destroy_writepagecache();
  1092. out1:
  1093. nfs_destroy_readpagecache();
  1094. out2:
  1095. nfs_destroy_inodecache();
  1096. out3:
  1097. nfs_destroy_nfspagecache();
  1098. out4:
  1099. nfs_fs_proc_exit();
  1100. out5:
  1101. return err;
  1102. }
  1103. static void __exit exit_nfs_fs(void)
  1104. {
  1105. nfs_destroy_directcache();
  1106. nfs_destroy_writepagecache();
  1107. nfs_destroy_readpagecache();
  1108. nfs_destroy_inodecache();
  1109. nfs_destroy_nfspagecache();
  1110. #ifdef CONFIG_PROC_FS
  1111. rpc_proc_unregister("nfs");
  1112. #endif
  1113. unregister_nfs_fs();
  1114. nfs_fs_proc_exit();
  1115. }
  1116. /* Not quite true; I just maintain it */
  1117. MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
  1118. MODULE_LICENSE("GPL");
  1119. module_init(init_nfs_fs)
  1120. module_exit(exit_nfs_fs)