inode.c 35 KB

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