inode.c 42 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486
  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@lxorguk.ukuu.org.uk>, 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/sched.h>
  18. #include <linux/time.h>
  19. #include <linux/kernel.h>
  20. #include <linux/mm.h>
  21. #include <linux/string.h>
  22. #include <linux/stat.h>
  23. #include <linux/errno.h>
  24. #include <linux/unistd.h>
  25. #include <linux/sunrpc/clnt.h>
  26. #include <linux/sunrpc/stats.h>
  27. #include <linux/sunrpc/metrics.h>
  28. #include <linux/nfs_fs.h>
  29. #include <linux/nfs_mount.h>
  30. #include <linux/nfs4_mount.h>
  31. #include <linux/lockd/bind.h>
  32. #include <linux/smp_lock.h>
  33. #include <linux/seq_file.h>
  34. #include <linux/mount.h>
  35. #include <linux/nfs_idmap.h>
  36. #include <linux/vfs.h>
  37. #include <linux/inet.h>
  38. #include <linux/nfs_xdr.h>
  39. #include <asm/system.h>
  40. #include <asm/uaccess.h>
  41. #include "nfs4_fs.h"
  42. #include "callback.h"
  43. #include "delegation.h"
  44. #include "iostat.h"
  45. #include "internal.h"
  46. #define NFSDBG_FACILITY NFSDBG_VFS
  47. #define NFS_64_BIT_INODE_NUMBERS_ENABLED 1
  48. /* Default is to see 64-bit inode numbers */
  49. static int enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED;
  50. static void nfs_invalidate_inode(struct inode *);
  51. static int nfs_update_inode(struct inode *, struct nfs_fattr *);
  52. static struct kmem_cache * nfs_inode_cachep;
  53. static inline unsigned long
  54. nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
  55. {
  56. return nfs_fileid_to_ino_t(fattr->fileid);
  57. }
  58. /**
  59. * nfs_compat_user_ino64 - returns the user-visible inode number
  60. * @fileid: 64-bit fileid
  61. *
  62. * This function returns a 32-bit inode number if the boot parameter
  63. * nfs.enable_ino64 is zero.
  64. */
  65. u64 nfs_compat_user_ino64(u64 fileid)
  66. {
  67. int ino;
  68. if (enable_ino64)
  69. return fileid;
  70. ino = fileid;
  71. if (sizeof(ino) < sizeof(fileid))
  72. ino ^= fileid >> (sizeof(fileid)-sizeof(ino)) * 8;
  73. return ino;
  74. }
  75. int nfs_write_inode(struct inode *inode, int sync)
  76. {
  77. int ret;
  78. if (sync) {
  79. ret = filemap_fdatawait(inode->i_mapping);
  80. if (ret == 0)
  81. ret = nfs_commit_inode(inode, FLUSH_SYNC);
  82. } else
  83. ret = nfs_commit_inode(inode, 0);
  84. if (ret >= 0)
  85. return 0;
  86. __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
  87. return ret;
  88. }
  89. void nfs_clear_inode(struct inode *inode)
  90. {
  91. /*
  92. * The following should never happen...
  93. */
  94. BUG_ON(nfs_have_writebacks(inode));
  95. BUG_ON(!list_empty(&NFS_I(inode)->open_files));
  96. nfs_zap_acl_cache(inode);
  97. nfs_access_zap_cache(inode);
  98. }
  99. /**
  100. * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
  101. */
  102. int nfs_sync_mapping(struct address_space *mapping)
  103. {
  104. int ret;
  105. if (mapping->nrpages == 0)
  106. return 0;
  107. unmap_mapping_range(mapping, 0, 0, 0);
  108. ret = filemap_write_and_wait(mapping);
  109. if (ret != 0)
  110. goto out;
  111. ret = nfs_wb_all(mapping->host);
  112. out:
  113. return ret;
  114. }
  115. /*
  116. * Invalidate the local caches
  117. */
  118. static void nfs_zap_caches_locked(struct inode *inode)
  119. {
  120. struct nfs_inode *nfsi = NFS_I(inode);
  121. int mode = inode->i_mode;
  122. nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
  123. nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
  124. nfsi->attrtimeo_timestamp = jiffies;
  125. memset(NFS_COOKIEVERF(inode), 0, sizeof(NFS_COOKIEVERF(inode)));
  126. if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode))
  127. nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
  128. else
  129. nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL|NFS_INO_REVAL_PAGECACHE;
  130. }
  131. void nfs_zap_caches(struct inode *inode)
  132. {
  133. spin_lock(&inode->i_lock);
  134. nfs_zap_caches_locked(inode);
  135. spin_unlock(&inode->i_lock);
  136. }
  137. void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
  138. {
  139. if (mapping->nrpages != 0) {
  140. spin_lock(&inode->i_lock);
  141. NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA;
  142. spin_unlock(&inode->i_lock);
  143. }
  144. }
  145. void nfs_zap_acl_cache(struct inode *inode)
  146. {
  147. void (*clear_acl_cache)(struct inode *);
  148. clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
  149. if (clear_acl_cache != NULL)
  150. clear_acl_cache(inode);
  151. spin_lock(&inode->i_lock);
  152. NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
  153. spin_unlock(&inode->i_lock);
  154. }
  155. void nfs_invalidate_atime(struct inode *inode)
  156. {
  157. spin_lock(&inode->i_lock);
  158. NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATIME;
  159. spin_unlock(&inode->i_lock);
  160. }
  161. /*
  162. * Invalidate, but do not unhash, the inode.
  163. * NB: must be called with inode->i_lock held!
  164. */
  165. static void nfs_invalidate_inode(struct inode *inode)
  166. {
  167. set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
  168. nfs_zap_caches_locked(inode);
  169. }
  170. struct nfs_find_desc {
  171. struct nfs_fh *fh;
  172. struct nfs_fattr *fattr;
  173. };
  174. /*
  175. * In NFSv3 we can have 64bit inode numbers. In order to support
  176. * this, and re-exported directories (also seen in NFSv2)
  177. * we are forced to allow 2 different inodes to have the same
  178. * i_ino.
  179. */
  180. static int
  181. nfs_find_actor(struct inode *inode, void *opaque)
  182. {
  183. struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
  184. struct nfs_fh *fh = desc->fh;
  185. struct nfs_fattr *fattr = desc->fattr;
  186. if (NFS_FILEID(inode) != fattr->fileid)
  187. return 0;
  188. if (nfs_compare_fh(NFS_FH(inode), fh))
  189. return 0;
  190. if (is_bad_inode(inode) || NFS_STALE(inode))
  191. return 0;
  192. return 1;
  193. }
  194. static int
  195. nfs_init_locked(struct inode *inode, void *opaque)
  196. {
  197. struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
  198. struct nfs_fattr *fattr = desc->fattr;
  199. set_nfs_fileid(inode, fattr->fileid);
  200. nfs_copy_fh(NFS_FH(inode), desc->fh);
  201. return 0;
  202. }
  203. /* Don't use READDIRPLUS on directories that we believe are too large */
  204. #define NFS_LIMIT_READDIRPLUS (8*PAGE_SIZE)
  205. /*
  206. * This is our front-end to iget that looks up inodes by file handle
  207. * instead of inode number.
  208. */
  209. struct inode *
  210. nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
  211. {
  212. struct nfs_find_desc desc = {
  213. .fh = fh,
  214. .fattr = fattr
  215. };
  216. struct inode *inode = ERR_PTR(-ENOENT);
  217. unsigned long hash;
  218. if ((fattr->valid & NFS_ATTR_FATTR_FILEID) == 0)
  219. goto out_no_inode;
  220. if ((fattr->valid & NFS_ATTR_FATTR_TYPE) == 0)
  221. goto out_no_inode;
  222. hash = nfs_fattr_to_ino_t(fattr);
  223. inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
  224. if (inode == NULL) {
  225. inode = ERR_PTR(-ENOMEM);
  226. goto out_no_inode;
  227. }
  228. if (inode->i_state & I_NEW) {
  229. struct nfs_inode *nfsi = NFS_I(inode);
  230. unsigned long now = jiffies;
  231. /* We set i_ino for the few things that still rely on it,
  232. * such as stat(2) */
  233. inode->i_ino = hash;
  234. /* We can't support update_atime(), since the server will reset it */
  235. inode->i_flags |= S_NOATIME|S_NOCMTIME;
  236. inode->i_mode = fattr->mode;
  237. /* Why so? Because we want revalidate for devices/FIFOs, and
  238. * that's precisely what we have in nfs_file_inode_operations.
  239. */
  240. inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
  241. if (S_ISREG(inode->i_mode)) {
  242. inode->i_fop = &nfs_file_operations;
  243. inode->i_data.a_ops = &nfs_file_aops;
  244. inode->i_data.backing_dev_info = &NFS_SB(sb)->backing_dev_info;
  245. } else if (S_ISDIR(inode->i_mode)) {
  246. inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
  247. inode->i_fop = &nfs_dir_operations;
  248. if (nfs_server_capable(inode, NFS_CAP_READDIRPLUS)
  249. && fattr->size <= NFS_LIMIT_READDIRPLUS)
  250. set_bit(NFS_INO_ADVISE_RDPLUS, &NFS_I(inode)->flags);
  251. /* Deal with crossing mountpoints */
  252. if ((fattr->valid & NFS_ATTR_FATTR_FSID)
  253. && !nfs_fsid_equal(&NFS_SB(sb)->fsid, &fattr->fsid)) {
  254. if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
  255. inode->i_op = &nfs_referral_inode_operations;
  256. else
  257. inode->i_op = &nfs_mountpoint_inode_operations;
  258. inode->i_fop = NULL;
  259. set_bit(NFS_INO_MOUNTPOINT, &nfsi->flags);
  260. }
  261. } else if (S_ISLNK(inode->i_mode))
  262. inode->i_op = &nfs_symlink_inode_operations;
  263. else
  264. init_special_inode(inode, inode->i_mode, fattr->rdev);
  265. memset(&inode->i_atime, 0, sizeof(inode->i_atime));
  266. memset(&inode->i_mtime, 0, sizeof(inode->i_mtime));
  267. memset(&inode->i_ctime, 0, sizeof(inode->i_ctime));
  268. nfsi->change_attr = 0;
  269. inode->i_size = 0;
  270. inode->i_nlink = 0;
  271. inode->i_uid = -2;
  272. inode->i_gid = -2;
  273. inode->i_blocks = 0;
  274. memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
  275. nfsi->read_cache_jiffies = fattr->time_start;
  276. nfsi->attr_gencount = fattr->gencount;
  277. if (fattr->valid & NFS_ATTR_FATTR_ATIME)
  278. inode->i_atime = fattr->atime;
  279. if (fattr->valid & NFS_ATTR_FATTR_MTIME)
  280. inode->i_mtime = fattr->mtime;
  281. if (fattr->valid & NFS_ATTR_FATTR_CTIME)
  282. inode->i_ctime = fattr->ctime;
  283. if (fattr->valid & NFS_ATTR_FATTR_CHANGE)
  284. nfsi->change_attr = fattr->change_attr;
  285. if (fattr->valid & NFS_ATTR_FATTR_SIZE)
  286. inode->i_size = nfs_size_to_loff_t(fattr->size);
  287. if (fattr->valid & NFS_ATTR_FATTR_NLINK)
  288. inode->i_nlink = fattr->nlink;
  289. if (fattr->valid & NFS_ATTR_FATTR_OWNER)
  290. inode->i_uid = fattr->uid;
  291. if (fattr->valid & NFS_ATTR_FATTR_GROUP)
  292. inode->i_gid = fattr->gid;
  293. if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
  294. inode->i_blocks = fattr->du.nfs2.blocks;
  295. if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
  296. /*
  297. * report the blocks in 512byte units
  298. */
  299. inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
  300. }
  301. nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
  302. nfsi->attrtimeo_timestamp = now;
  303. nfsi->access_cache = RB_ROOT;
  304. unlock_new_inode(inode);
  305. } else
  306. nfs_refresh_inode(inode, fattr);
  307. dprintk("NFS: nfs_fhget(%s/%Ld ct=%d)\n",
  308. inode->i_sb->s_id,
  309. (long long)NFS_FILEID(inode),
  310. atomic_read(&inode->i_count));
  311. out:
  312. return inode;
  313. out_no_inode:
  314. dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
  315. goto out;
  316. }
  317. #define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET|ATTR_FILE)
  318. int
  319. nfs_setattr(struct dentry *dentry, struct iattr *attr)
  320. {
  321. struct inode *inode = dentry->d_inode;
  322. struct nfs_fattr fattr;
  323. int error;
  324. nfs_inc_stats(inode, NFSIOS_VFSSETATTR);
  325. /* skip mode change if it's just for clearing setuid/setgid */
  326. if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
  327. attr->ia_valid &= ~ATTR_MODE;
  328. if (attr->ia_valid & ATTR_SIZE) {
  329. if (!S_ISREG(inode->i_mode) || attr->ia_size == i_size_read(inode))
  330. attr->ia_valid &= ~ATTR_SIZE;
  331. }
  332. /* Optimization: if the end result is no change, don't RPC */
  333. attr->ia_valid &= NFS_VALID_ATTRS;
  334. if ((attr->ia_valid & ~ATTR_FILE) == 0)
  335. return 0;
  336. /* Write all dirty data */
  337. if (S_ISREG(inode->i_mode)) {
  338. filemap_write_and_wait(inode->i_mapping);
  339. nfs_wb_all(inode);
  340. }
  341. /*
  342. * Return any delegations if we're going to change ACLs
  343. */
  344. if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0)
  345. nfs_inode_return_delegation(inode);
  346. error = NFS_PROTO(inode)->setattr(dentry, &fattr, attr);
  347. if (error == 0)
  348. nfs_refresh_inode(inode, &fattr);
  349. return error;
  350. }
  351. /**
  352. * nfs_vmtruncate - unmap mappings "freed" by truncate() syscall
  353. * @inode: inode of the file used
  354. * @offset: file offset to start truncating
  355. *
  356. * This is a copy of the common vmtruncate, but with the locking
  357. * corrected to take into account the fact that NFS requires
  358. * inode->i_size to be updated under the inode->i_lock.
  359. */
  360. static int nfs_vmtruncate(struct inode * inode, loff_t offset)
  361. {
  362. if (i_size_read(inode) < offset) {
  363. unsigned long limit;
  364. limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
  365. if (limit != RLIM_INFINITY && offset > limit)
  366. goto out_sig;
  367. if (offset > inode->i_sb->s_maxbytes)
  368. goto out_big;
  369. spin_lock(&inode->i_lock);
  370. i_size_write(inode, offset);
  371. spin_unlock(&inode->i_lock);
  372. } else {
  373. struct address_space *mapping = inode->i_mapping;
  374. /*
  375. * truncation of in-use swapfiles is disallowed - it would
  376. * cause subsequent swapout to scribble on the now-freed
  377. * blocks.
  378. */
  379. if (IS_SWAPFILE(inode))
  380. return -ETXTBSY;
  381. spin_lock(&inode->i_lock);
  382. i_size_write(inode, offset);
  383. spin_unlock(&inode->i_lock);
  384. /*
  385. * unmap_mapping_range is called twice, first simply for
  386. * efficiency so that truncate_inode_pages does fewer
  387. * single-page unmaps. However after this first call, and
  388. * before truncate_inode_pages finishes, it is possible for
  389. * private pages to be COWed, which remain after
  390. * truncate_inode_pages finishes, hence the second
  391. * unmap_mapping_range call must be made for correctness.
  392. */
  393. unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
  394. truncate_inode_pages(mapping, offset);
  395. unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
  396. }
  397. return 0;
  398. out_sig:
  399. send_sig(SIGXFSZ, current, 0);
  400. out_big:
  401. return -EFBIG;
  402. }
  403. /**
  404. * nfs_setattr_update_inode - Update inode metadata after a setattr call.
  405. * @inode: pointer to struct inode
  406. * @attr: pointer to struct iattr
  407. *
  408. * Note: we do this in the *proc.c in order to ensure that
  409. * it works for things like exclusive creates too.
  410. */
  411. void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr)
  412. {
  413. if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) {
  414. spin_lock(&inode->i_lock);
  415. if ((attr->ia_valid & ATTR_MODE) != 0) {
  416. int mode = attr->ia_mode & S_IALLUGO;
  417. mode |= inode->i_mode & ~S_IALLUGO;
  418. inode->i_mode = mode;
  419. }
  420. if ((attr->ia_valid & ATTR_UID) != 0)
  421. inode->i_uid = attr->ia_uid;
  422. if ((attr->ia_valid & ATTR_GID) != 0)
  423. inode->i_gid = attr->ia_gid;
  424. NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
  425. spin_unlock(&inode->i_lock);
  426. }
  427. if ((attr->ia_valid & ATTR_SIZE) != 0) {
  428. nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
  429. nfs_vmtruncate(inode, attr->ia_size);
  430. }
  431. }
  432. int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
  433. {
  434. struct inode *inode = dentry->d_inode;
  435. int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
  436. int err;
  437. /*
  438. * Flush out writes to the server in order to update c/mtime.
  439. *
  440. * Hold the i_mutex to suspend application writes temporarily;
  441. * this prevents long-running writing applications from blocking
  442. * nfs_wb_nocommit.
  443. */
  444. if (S_ISREG(inode->i_mode)) {
  445. mutex_lock(&inode->i_mutex);
  446. nfs_wb_nocommit(inode);
  447. mutex_unlock(&inode->i_mutex);
  448. }
  449. /*
  450. * We may force a getattr if the user cares about atime.
  451. *
  452. * Note that we only have to check the vfsmount flags here:
  453. * - NFS always sets S_NOATIME by so checking it would give a
  454. * bogus result
  455. * - NFS never sets MS_NOATIME or MS_NODIRATIME so there is
  456. * no point in checking those.
  457. */
  458. if ((mnt->mnt_flags & MNT_NOATIME) ||
  459. ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
  460. need_atime = 0;
  461. if (need_atime)
  462. err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
  463. else
  464. err = nfs_revalidate_inode(NFS_SERVER(inode), inode);
  465. if (!err) {
  466. generic_fillattr(inode, stat);
  467. stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
  468. }
  469. return err;
  470. }
  471. static struct nfs_open_context *alloc_nfs_open_context(struct vfsmount *mnt, struct dentry *dentry, struct rpc_cred *cred)
  472. {
  473. struct nfs_open_context *ctx;
  474. ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
  475. if (ctx != NULL) {
  476. ctx->path.dentry = dget(dentry);
  477. ctx->path.mnt = mntget(mnt);
  478. ctx->cred = get_rpccred(cred);
  479. ctx->state = NULL;
  480. ctx->lockowner = current->files;
  481. ctx->flags = 0;
  482. ctx->error = 0;
  483. ctx->dir_cookie = 0;
  484. atomic_set(&ctx->count, 1);
  485. }
  486. return ctx;
  487. }
  488. struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
  489. {
  490. if (ctx != NULL)
  491. atomic_inc(&ctx->count);
  492. return ctx;
  493. }
  494. static void __put_nfs_open_context(struct nfs_open_context *ctx, int wait)
  495. {
  496. struct inode *inode;
  497. if (ctx == NULL)
  498. return;
  499. inode = ctx->path.dentry->d_inode;
  500. if (!atomic_dec_and_lock(&ctx->count, &inode->i_lock))
  501. return;
  502. list_del(&ctx->list);
  503. spin_unlock(&inode->i_lock);
  504. if (ctx->state != NULL) {
  505. if (wait)
  506. nfs4_close_sync(&ctx->path, ctx->state, ctx->mode);
  507. else
  508. nfs4_close_state(&ctx->path, ctx->state, ctx->mode);
  509. }
  510. if (ctx->cred != NULL)
  511. put_rpccred(ctx->cred);
  512. path_put(&ctx->path);
  513. kfree(ctx);
  514. }
  515. void put_nfs_open_context(struct nfs_open_context *ctx)
  516. {
  517. __put_nfs_open_context(ctx, 0);
  518. }
  519. static void put_nfs_open_context_sync(struct nfs_open_context *ctx)
  520. {
  521. __put_nfs_open_context(ctx, 1);
  522. }
  523. /*
  524. * Ensure that mmap has a recent RPC credential for use when writing out
  525. * shared pages
  526. */
  527. static void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
  528. {
  529. struct inode *inode = filp->f_path.dentry->d_inode;
  530. struct nfs_inode *nfsi = NFS_I(inode);
  531. filp->private_data = get_nfs_open_context(ctx);
  532. spin_lock(&inode->i_lock);
  533. list_add(&ctx->list, &nfsi->open_files);
  534. spin_unlock(&inode->i_lock);
  535. }
  536. /*
  537. * Given an inode, search for an open context with the desired characteristics
  538. */
  539. struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode)
  540. {
  541. struct nfs_inode *nfsi = NFS_I(inode);
  542. struct nfs_open_context *pos, *ctx = NULL;
  543. spin_lock(&inode->i_lock);
  544. list_for_each_entry(pos, &nfsi->open_files, list) {
  545. if (cred != NULL && pos->cred != cred)
  546. continue;
  547. if ((pos->mode & mode) == mode) {
  548. ctx = get_nfs_open_context(pos);
  549. break;
  550. }
  551. }
  552. spin_unlock(&inode->i_lock);
  553. return ctx;
  554. }
  555. static void nfs_file_clear_open_context(struct file *filp)
  556. {
  557. struct inode *inode = filp->f_path.dentry->d_inode;
  558. struct nfs_open_context *ctx = nfs_file_open_context(filp);
  559. if (ctx) {
  560. filp->private_data = NULL;
  561. spin_lock(&inode->i_lock);
  562. list_move_tail(&ctx->list, &NFS_I(inode)->open_files);
  563. spin_unlock(&inode->i_lock);
  564. put_nfs_open_context_sync(ctx);
  565. }
  566. }
  567. /*
  568. * These allocate and release file read/write context information.
  569. */
  570. int nfs_open(struct inode *inode, struct file *filp)
  571. {
  572. struct nfs_open_context *ctx;
  573. struct rpc_cred *cred;
  574. cred = rpc_lookup_cred();
  575. if (IS_ERR(cred))
  576. return PTR_ERR(cred);
  577. ctx = alloc_nfs_open_context(filp->f_path.mnt, filp->f_path.dentry, cred);
  578. put_rpccred(cred);
  579. if (ctx == NULL)
  580. return -ENOMEM;
  581. ctx->mode = filp->f_mode;
  582. nfs_file_set_open_context(filp, ctx);
  583. put_nfs_open_context(ctx);
  584. return 0;
  585. }
  586. int nfs_release(struct inode *inode, struct file *filp)
  587. {
  588. nfs_file_clear_open_context(filp);
  589. return 0;
  590. }
  591. /*
  592. * This function is called whenever some part of NFS notices that
  593. * the cached attributes have to be refreshed.
  594. */
  595. int
  596. __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
  597. {
  598. int status = -ESTALE;
  599. struct nfs_fattr fattr;
  600. struct nfs_inode *nfsi = NFS_I(inode);
  601. dfprintk(PAGECACHE, "NFS: revalidating (%s/%Ld)\n",
  602. inode->i_sb->s_id, (long long)NFS_FILEID(inode));
  603. if (is_bad_inode(inode))
  604. goto out;
  605. if (NFS_STALE(inode))
  606. goto out;
  607. nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
  608. status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), &fattr);
  609. if (status != 0) {
  610. dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) getattr failed, error=%d\n",
  611. inode->i_sb->s_id,
  612. (long long)NFS_FILEID(inode), status);
  613. if (status == -ESTALE) {
  614. nfs_zap_caches(inode);
  615. if (!S_ISDIR(inode->i_mode))
  616. set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
  617. }
  618. goto out;
  619. }
  620. status = nfs_refresh_inode(inode, &fattr);
  621. if (status) {
  622. dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Ld) refresh failed, error=%d\n",
  623. inode->i_sb->s_id,
  624. (long long)NFS_FILEID(inode), status);
  625. goto out;
  626. }
  627. if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
  628. nfs_zap_acl_cache(inode);
  629. dfprintk(PAGECACHE, "NFS: (%s/%Ld) revalidation complete\n",
  630. inode->i_sb->s_id,
  631. (long long)NFS_FILEID(inode));
  632. out:
  633. return status;
  634. }
  635. int nfs_attribute_timeout(struct inode *inode)
  636. {
  637. struct nfs_inode *nfsi = NFS_I(inode);
  638. if (nfs_have_delegation(inode, FMODE_READ))
  639. return 0;
  640. return !time_in_range_open(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo);
  641. }
  642. /**
  643. * nfs_revalidate_inode - Revalidate the inode attributes
  644. * @server - pointer to nfs_server struct
  645. * @inode - pointer to inode struct
  646. *
  647. * Updates inode attribute information by retrieving the data from the server.
  648. */
  649. int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
  650. {
  651. if (!(NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATTR)
  652. && !nfs_attribute_timeout(inode))
  653. return NFS_STALE(inode) ? -ESTALE : 0;
  654. return __nfs_revalidate_inode(server, inode);
  655. }
  656. static int nfs_invalidate_mapping_nolock(struct inode *inode, struct address_space *mapping)
  657. {
  658. struct nfs_inode *nfsi = NFS_I(inode);
  659. if (mapping->nrpages != 0) {
  660. int ret = invalidate_inode_pages2(mapping);
  661. if (ret < 0)
  662. return ret;
  663. }
  664. spin_lock(&inode->i_lock);
  665. nfsi->cache_validity &= ~NFS_INO_INVALID_DATA;
  666. if (S_ISDIR(inode->i_mode))
  667. memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
  668. spin_unlock(&inode->i_lock);
  669. nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
  670. dfprintk(PAGECACHE, "NFS: (%s/%Ld) data cache invalidated\n",
  671. inode->i_sb->s_id, (long long)NFS_FILEID(inode));
  672. return 0;
  673. }
  674. static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
  675. {
  676. int ret = 0;
  677. mutex_lock(&inode->i_mutex);
  678. if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_DATA) {
  679. ret = nfs_sync_mapping(mapping);
  680. if (ret == 0)
  681. ret = nfs_invalidate_mapping_nolock(inode, mapping);
  682. }
  683. mutex_unlock(&inode->i_mutex);
  684. return ret;
  685. }
  686. /**
  687. * nfs_revalidate_mapping_nolock - Revalidate the pagecache
  688. * @inode - pointer to host inode
  689. * @mapping - pointer to mapping
  690. */
  691. int nfs_revalidate_mapping_nolock(struct inode *inode, struct address_space *mapping)
  692. {
  693. struct nfs_inode *nfsi = NFS_I(inode);
  694. int ret = 0;
  695. if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
  696. || nfs_attribute_timeout(inode) || NFS_STALE(inode)) {
  697. ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
  698. if (ret < 0)
  699. goto out;
  700. }
  701. if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
  702. ret = nfs_invalidate_mapping_nolock(inode, mapping);
  703. out:
  704. return ret;
  705. }
  706. /**
  707. * nfs_revalidate_mapping - Revalidate the pagecache
  708. * @inode - pointer to host inode
  709. * @mapping - pointer to mapping
  710. *
  711. * This version of the function will take the inode->i_mutex and attempt to
  712. * flush out all dirty data if it needs to invalidate the page cache.
  713. */
  714. int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
  715. {
  716. struct nfs_inode *nfsi = NFS_I(inode);
  717. int ret = 0;
  718. if ((nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
  719. || nfs_attribute_timeout(inode) || NFS_STALE(inode)) {
  720. ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
  721. if (ret < 0)
  722. goto out;
  723. }
  724. if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
  725. ret = nfs_invalidate_mapping(inode, mapping);
  726. out:
  727. return ret;
  728. }
  729. static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
  730. {
  731. struct nfs_inode *nfsi = NFS_I(inode);
  732. if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE)
  733. && (fattr->valid & NFS_ATTR_FATTR_CHANGE)
  734. && nfsi->change_attr == fattr->pre_change_attr) {
  735. nfsi->change_attr = fattr->change_attr;
  736. if (S_ISDIR(inode->i_mode))
  737. nfsi->cache_validity |= NFS_INO_INVALID_DATA;
  738. }
  739. /* If we have atomic WCC data, we may update some attributes */
  740. if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME)
  741. && (fattr->valid & NFS_ATTR_FATTR_CTIME)
  742. && timespec_equal(&inode->i_ctime, &fattr->pre_ctime))
  743. memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
  744. if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME)
  745. && (fattr->valid & NFS_ATTR_FATTR_MTIME)
  746. && timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) {
  747. memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
  748. if (S_ISDIR(inode->i_mode))
  749. nfsi->cache_validity |= NFS_INO_INVALID_DATA;
  750. }
  751. if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE)
  752. && (fattr->valid & NFS_ATTR_FATTR_SIZE)
  753. && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size)
  754. && nfsi->npages == 0)
  755. i_size_write(inode, nfs_size_to_loff_t(fattr->size));
  756. }
  757. /**
  758. * nfs_check_inode_attributes - verify consistency of the inode attribute cache
  759. * @inode - pointer to inode
  760. * @fattr - updated attributes
  761. *
  762. * Verifies the attribute cache. If we have just changed the attributes,
  763. * so that fattr carries weak cache consistency data, then it may
  764. * also update the ctime/mtime/change_attribute.
  765. */
  766. static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
  767. {
  768. struct nfs_inode *nfsi = NFS_I(inode);
  769. loff_t cur_size, new_isize;
  770. unsigned long invalid = 0;
  771. /* Has the inode gone and changed behind our back? */
  772. if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid)
  773. return -EIO;
  774. if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
  775. return -EIO;
  776. if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
  777. nfsi->change_attr != fattr->change_attr)
  778. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
  779. /* Verify a few of the more important attributes */
  780. if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec_equal(&inode->i_mtime, &fattr->mtime))
  781. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
  782. if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
  783. cur_size = i_size_read(inode);
  784. new_isize = nfs_size_to_loff_t(fattr->size);
  785. if (cur_size != new_isize && nfsi->npages == 0)
  786. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
  787. }
  788. /* Have any file permissions changed? */
  789. if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO))
  790. invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
  791. if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && inode->i_uid != fattr->uid)
  792. invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
  793. if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && inode->i_gid != fattr->gid)
  794. invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
  795. /* Has the link count changed? */
  796. if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink)
  797. invalid |= NFS_INO_INVALID_ATTR;
  798. if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec_equal(&inode->i_atime, &fattr->atime))
  799. invalid |= NFS_INO_INVALID_ATIME;
  800. if (invalid != 0)
  801. nfsi->cache_validity |= invalid;
  802. nfsi->read_cache_jiffies = fattr->time_start;
  803. return 0;
  804. }
  805. static int nfs_ctime_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
  806. {
  807. if (!(fattr->valid & NFS_ATTR_FATTR_CTIME))
  808. return 0;
  809. return timespec_compare(&fattr->ctime, &inode->i_ctime) > 0;
  810. }
  811. static int nfs_size_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
  812. {
  813. if (!(fattr->valid & NFS_ATTR_FATTR_SIZE))
  814. return 0;
  815. return nfs_size_to_loff_t(fattr->size) > i_size_read(inode);
  816. }
  817. static atomic_long_t nfs_attr_generation_counter;
  818. static unsigned long nfs_read_attr_generation_counter(void)
  819. {
  820. return atomic_long_read(&nfs_attr_generation_counter);
  821. }
  822. unsigned long nfs_inc_attr_generation_counter(void)
  823. {
  824. return atomic_long_inc_return(&nfs_attr_generation_counter);
  825. }
  826. void nfs_fattr_init(struct nfs_fattr *fattr)
  827. {
  828. fattr->valid = 0;
  829. fattr->time_start = jiffies;
  830. fattr->gencount = nfs_inc_attr_generation_counter();
  831. }
  832. /**
  833. * nfs_inode_attrs_need_update - check if the inode attributes need updating
  834. * @inode - pointer to inode
  835. * @fattr - attributes
  836. *
  837. * Attempt to divine whether or not an RPC call reply carrying stale
  838. * attributes got scheduled after another call carrying updated ones.
  839. *
  840. * To do so, the function first assumes that a more recent ctime means
  841. * that the attributes in fattr are newer, however it also attempt to
  842. * catch the case where ctime either didn't change, or went backwards
  843. * (if someone reset the clock on the server) by looking at whether
  844. * or not this RPC call was started after the inode was last updated.
  845. * Note also the check for wraparound of 'attr_gencount'
  846. *
  847. * The function returns 'true' if it thinks the attributes in 'fattr' are
  848. * more recent than the ones cached in the inode.
  849. *
  850. */
  851. static int nfs_inode_attrs_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
  852. {
  853. const struct nfs_inode *nfsi = NFS_I(inode);
  854. return ((long)fattr->gencount - (long)nfsi->attr_gencount) > 0 ||
  855. nfs_ctime_need_update(inode, fattr) ||
  856. nfs_size_need_update(inode, fattr) ||
  857. ((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0);
  858. }
  859. static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
  860. {
  861. if (nfs_inode_attrs_need_update(inode, fattr))
  862. return nfs_update_inode(inode, fattr);
  863. return nfs_check_inode_attributes(inode, fattr);
  864. }
  865. /**
  866. * nfs_refresh_inode - try to update the inode attribute cache
  867. * @inode - pointer to inode
  868. * @fattr - updated attributes
  869. *
  870. * Check that an RPC call that returned attributes has not overlapped with
  871. * other recent updates of the inode metadata, then decide whether it is
  872. * safe to do a full update of the inode attributes, or whether just to
  873. * call nfs_check_inode_attributes.
  874. */
  875. int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
  876. {
  877. int status;
  878. if ((fattr->valid & NFS_ATTR_FATTR) == 0)
  879. return 0;
  880. spin_lock(&inode->i_lock);
  881. status = nfs_refresh_inode_locked(inode, fattr);
  882. spin_unlock(&inode->i_lock);
  883. return status;
  884. }
  885. static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
  886. {
  887. struct nfs_inode *nfsi = NFS_I(inode);
  888. nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
  889. if (S_ISDIR(inode->i_mode))
  890. nfsi->cache_validity |= NFS_INO_INVALID_DATA;
  891. if ((fattr->valid & NFS_ATTR_FATTR) == 0)
  892. return 0;
  893. return nfs_refresh_inode_locked(inode, fattr);
  894. }
  895. /**
  896. * nfs_post_op_update_inode - try to update the inode attribute cache
  897. * @inode - pointer to inode
  898. * @fattr - updated attributes
  899. *
  900. * After an operation that has changed the inode metadata, mark the
  901. * attribute cache as being invalid, then try to update it.
  902. *
  903. * NB: if the server didn't return any post op attributes, this
  904. * function will force the retrieval of attributes before the next
  905. * NFS request. Thus it should be used only for operations that
  906. * are expected to change one or more attributes, to avoid
  907. * unnecessary NFS requests and trips through nfs_update_inode().
  908. */
  909. int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
  910. {
  911. int status;
  912. spin_lock(&inode->i_lock);
  913. status = nfs_post_op_update_inode_locked(inode, fattr);
  914. spin_unlock(&inode->i_lock);
  915. return status;
  916. }
  917. /**
  918. * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache
  919. * @inode - pointer to inode
  920. * @fattr - updated attributes
  921. *
  922. * After an operation that has changed the inode metadata, mark the
  923. * attribute cache as being invalid, then try to update it. Fake up
  924. * weak cache consistency data, if none exist.
  925. *
  926. * This function is mainly designed to be used by the ->write_done() functions.
  927. */
  928. int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr)
  929. {
  930. int status;
  931. spin_lock(&inode->i_lock);
  932. /* Don't do a WCC update if these attributes are already stale */
  933. if ((fattr->valid & NFS_ATTR_FATTR) == 0 ||
  934. !nfs_inode_attrs_need_update(inode, fattr)) {
  935. fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE
  936. | NFS_ATTR_FATTR_PRESIZE
  937. | NFS_ATTR_FATTR_PREMTIME
  938. | NFS_ATTR_FATTR_PRECTIME);
  939. goto out_noforce;
  940. }
  941. if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
  942. (fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) {
  943. fattr->pre_change_attr = NFS_I(inode)->change_attr;
  944. fattr->valid |= NFS_ATTR_FATTR_PRECHANGE;
  945. }
  946. if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 &&
  947. (fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) {
  948. memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime));
  949. fattr->valid |= NFS_ATTR_FATTR_PRECTIME;
  950. }
  951. if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 &&
  952. (fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) {
  953. memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime));
  954. fattr->valid |= NFS_ATTR_FATTR_PREMTIME;
  955. }
  956. if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 &&
  957. (fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) {
  958. fattr->pre_size = i_size_read(inode);
  959. fattr->valid |= NFS_ATTR_FATTR_PRESIZE;
  960. }
  961. out_noforce:
  962. status = nfs_post_op_update_inode_locked(inode, fattr);
  963. spin_unlock(&inode->i_lock);
  964. return status;
  965. }
  966. /*
  967. * Many nfs protocol calls return the new file attributes after
  968. * an operation. Here we update the inode to reflect the state
  969. * of the server's inode.
  970. *
  971. * This is a bit tricky because we have to make sure all dirty pages
  972. * have been sent off to the server before calling invalidate_inode_pages.
  973. * To make sure no other process adds more write requests while we try
  974. * our best to flush them, we make them sleep during the attribute refresh.
  975. *
  976. * A very similar scenario holds for the dir cache.
  977. */
  978. static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
  979. {
  980. struct nfs_server *server;
  981. struct nfs_inode *nfsi = NFS_I(inode);
  982. loff_t cur_isize, new_isize;
  983. unsigned long invalid = 0;
  984. unsigned long now = jiffies;
  985. dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n",
  986. __func__, inode->i_sb->s_id, inode->i_ino,
  987. atomic_read(&inode->i_count), fattr->valid);
  988. if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid)
  989. goto out_fileid;
  990. /*
  991. * Make sure the inode's type hasn't changed.
  992. */
  993. if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
  994. goto out_changed;
  995. server = NFS_SERVER(inode);
  996. /* Update the fsid? */
  997. if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) &&
  998. !nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
  999. !test_bit(NFS_INO_MOUNTPOINT, &nfsi->flags))
  1000. server->fsid = fattr->fsid;
  1001. /*
  1002. * Update the read time so we don't revalidate too often.
  1003. */
  1004. nfsi->read_cache_jiffies = fattr->time_start;
  1005. if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) || (fattr->valid & (NFS_ATTR_FATTR_MTIME|NFS_ATTR_FATTR_CTIME)))
  1006. nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR
  1007. | NFS_INO_INVALID_ATIME
  1008. | NFS_INO_REVAL_PAGECACHE);
  1009. /* Do atomic weak cache consistency updates */
  1010. nfs_wcc_update_inode(inode, fattr);
  1011. /* More cache consistency checks */
  1012. if (fattr->valid & NFS_ATTR_FATTR_CHANGE) {
  1013. if (nfsi->change_attr != fattr->change_attr) {
  1014. dprintk("NFS: change_attr change on server for file %s/%ld\n",
  1015. inode->i_sb->s_id, inode->i_ino);
  1016. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
  1017. if (S_ISDIR(inode->i_mode))
  1018. nfs_force_lookup_revalidate(inode);
  1019. nfsi->change_attr = fattr->change_attr;
  1020. }
  1021. }
  1022. if (fattr->valid & NFS_ATTR_FATTR_MTIME) {
  1023. /* NFSv2/v3: Check if the mtime agrees */
  1024. if (!timespec_equal(&inode->i_mtime, &fattr->mtime)) {
  1025. dprintk("NFS: mtime change on server for file %s/%ld\n",
  1026. inode->i_sb->s_id, inode->i_ino);
  1027. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
  1028. if (S_ISDIR(inode->i_mode))
  1029. nfs_force_lookup_revalidate(inode);
  1030. memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
  1031. }
  1032. }
  1033. if (fattr->valid & NFS_ATTR_FATTR_CTIME) {
  1034. /* If ctime has changed we should definitely clear access+acl caches */
  1035. if (!timespec_equal(&inode->i_ctime, &fattr->ctime)) {
  1036. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
  1037. /* and probably clear data for a directory too as utimes can cause
  1038. * havoc with our cache.
  1039. */
  1040. if (S_ISDIR(inode->i_mode)) {
  1041. invalid |= NFS_INO_INVALID_DATA;
  1042. nfs_force_lookup_revalidate(inode);
  1043. }
  1044. memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
  1045. }
  1046. }
  1047. /* Check if our cached file size is stale */
  1048. if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
  1049. new_isize = nfs_size_to_loff_t(fattr->size);
  1050. cur_isize = i_size_read(inode);
  1051. if (new_isize != cur_isize) {
  1052. /* Do we perhaps have any outstanding writes, or has
  1053. * the file grown beyond our last write? */
  1054. if (nfsi->npages == 0 || new_isize > cur_isize) {
  1055. i_size_write(inode, new_isize);
  1056. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
  1057. }
  1058. dprintk("NFS: isize change on server for file %s/%ld\n",
  1059. inode->i_sb->s_id, inode->i_ino);
  1060. }
  1061. }
  1062. if (fattr->valid & NFS_ATTR_FATTR_ATIME)
  1063. memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));
  1064. if (fattr->valid & NFS_ATTR_FATTR_MODE) {
  1065. if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
  1066. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
  1067. inode->i_mode = fattr->mode;
  1068. }
  1069. }
  1070. if (fattr->valid & NFS_ATTR_FATTR_OWNER) {
  1071. if (inode->i_uid != fattr->uid) {
  1072. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
  1073. inode->i_uid = fattr->uid;
  1074. }
  1075. }
  1076. if (fattr->valid & NFS_ATTR_FATTR_GROUP) {
  1077. if (inode->i_gid != fattr->gid) {
  1078. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
  1079. inode->i_gid = fattr->gid;
  1080. }
  1081. }
  1082. if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
  1083. if (inode->i_nlink != fattr->nlink) {
  1084. invalid |= NFS_INO_INVALID_ATTR;
  1085. if (S_ISDIR(inode->i_mode))
  1086. invalid |= NFS_INO_INVALID_DATA;
  1087. inode->i_nlink = fattr->nlink;
  1088. }
  1089. }
  1090. if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
  1091. /*
  1092. * report the blocks in 512byte units
  1093. */
  1094. inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
  1095. }
  1096. if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
  1097. inode->i_blocks = fattr->du.nfs2.blocks;
  1098. /* Update attrtimeo value if we're out of the unstable period */
  1099. if (invalid & NFS_INO_INVALID_ATTR) {
  1100. nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
  1101. nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
  1102. nfsi->attrtimeo_timestamp = now;
  1103. nfsi->attr_gencount = nfs_inc_attr_generation_counter();
  1104. } else {
  1105. if (!time_in_range_open(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
  1106. if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))
  1107. nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
  1108. nfsi->attrtimeo_timestamp = now;
  1109. }
  1110. }
  1111. invalid &= ~NFS_INO_INVALID_ATTR;
  1112. /* Don't invalidate the data if we were to blame */
  1113. if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
  1114. || S_ISLNK(inode->i_mode)))
  1115. invalid &= ~NFS_INO_INVALID_DATA;
  1116. if (!nfs_have_delegation(inode, FMODE_READ) ||
  1117. (nfsi->cache_validity & NFS_INO_REVAL_FORCED))
  1118. nfsi->cache_validity |= invalid;
  1119. nfsi->cache_validity &= ~NFS_INO_REVAL_FORCED;
  1120. return 0;
  1121. out_changed:
  1122. /*
  1123. * Big trouble! The inode has become a different object.
  1124. */
  1125. printk(KERN_DEBUG "%s: inode %ld mode changed, %07o to %07o\n",
  1126. __func__, inode->i_ino, inode->i_mode, fattr->mode);
  1127. out_err:
  1128. /*
  1129. * No need to worry about unhashing the dentry, as the
  1130. * lookup validation will know that the inode is bad.
  1131. * (But we fall through to invalidate the caches.)
  1132. */
  1133. nfs_invalidate_inode(inode);
  1134. return -ESTALE;
  1135. out_fileid:
  1136. printk(KERN_ERR "NFS: server %s error: fileid changed\n"
  1137. "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
  1138. NFS_SERVER(inode)->nfs_client->cl_hostname, inode->i_sb->s_id,
  1139. (long long)nfsi->fileid, (long long)fattr->fileid);
  1140. goto out_err;
  1141. }
  1142. #ifdef CONFIG_NFS_V4
  1143. /*
  1144. * Clean out any remaining NFSv4 state that might be left over due
  1145. * to open() calls that passed nfs_atomic_lookup, but failed to call
  1146. * nfs_open().
  1147. */
  1148. void nfs4_clear_inode(struct inode *inode)
  1149. {
  1150. /* If we are holding a delegation, return it! */
  1151. nfs_inode_return_delegation_noreclaim(inode);
  1152. /* First call standard NFS clear_inode() code */
  1153. nfs_clear_inode(inode);
  1154. }
  1155. #endif
  1156. struct inode *nfs_alloc_inode(struct super_block *sb)
  1157. {
  1158. struct nfs_inode *nfsi;
  1159. nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
  1160. if (!nfsi)
  1161. return NULL;
  1162. nfsi->flags = 0UL;
  1163. nfsi->cache_validity = 0UL;
  1164. #ifdef CONFIG_NFS_V3_ACL
  1165. nfsi->acl_access = ERR_PTR(-EAGAIN);
  1166. nfsi->acl_default = ERR_PTR(-EAGAIN);
  1167. #endif
  1168. #ifdef CONFIG_NFS_V4
  1169. nfsi->nfs4_acl = NULL;
  1170. #endif /* CONFIG_NFS_V4 */
  1171. return &nfsi->vfs_inode;
  1172. }
  1173. void nfs_destroy_inode(struct inode *inode)
  1174. {
  1175. kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
  1176. }
  1177. static inline void nfs4_init_once(struct nfs_inode *nfsi)
  1178. {
  1179. #ifdef CONFIG_NFS_V4
  1180. INIT_LIST_HEAD(&nfsi->open_states);
  1181. nfsi->delegation = NULL;
  1182. nfsi->delegation_state = 0;
  1183. init_rwsem(&nfsi->rwsem);
  1184. #endif
  1185. }
  1186. static void init_once(void *foo)
  1187. {
  1188. struct nfs_inode *nfsi = (struct nfs_inode *) foo;
  1189. inode_init_once(&nfsi->vfs_inode);
  1190. INIT_LIST_HEAD(&nfsi->open_files);
  1191. INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
  1192. INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
  1193. INIT_RADIX_TREE(&nfsi->nfs_page_tree, GFP_ATOMIC);
  1194. nfsi->npages = 0;
  1195. atomic_set(&nfsi->silly_count, 1);
  1196. INIT_HLIST_HEAD(&nfsi->silly_list);
  1197. init_waitqueue_head(&nfsi->waitqueue);
  1198. nfs4_init_once(nfsi);
  1199. }
  1200. static int __init nfs_init_inodecache(void)
  1201. {
  1202. nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
  1203. sizeof(struct nfs_inode),
  1204. 0, (SLAB_RECLAIM_ACCOUNT|
  1205. SLAB_MEM_SPREAD),
  1206. init_once);
  1207. if (nfs_inode_cachep == NULL)
  1208. return -ENOMEM;
  1209. return 0;
  1210. }
  1211. static void nfs_destroy_inodecache(void)
  1212. {
  1213. kmem_cache_destroy(nfs_inode_cachep);
  1214. }
  1215. struct workqueue_struct *nfsiod_workqueue;
  1216. /*
  1217. * start up the nfsiod workqueue
  1218. */
  1219. static int nfsiod_start(void)
  1220. {
  1221. struct workqueue_struct *wq;
  1222. dprintk("RPC: creating workqueue nfsiod\n");
  1223. wq = create_singlethread_workqueue("nfsiod");
  1224. if (wq == NULL)
  1225. return -ENOMEM;
  1226. nfsiod_workqueue = wq;
  1227. return 0;
  1228. }
  1229. /*
  1230. * Destroy the nfsiod workqueue
  1231. */
  1232. static void nfsiod_stop(void)
  1233. {
  1234. struct workqueue_struct *wq;
  1235. wq = nfsiod_workqueue;
  1236. if (wq == NULL)
  1237. return;
  1238. nfsiod_workqueue = NULL;
  1239. destroy_workqueue(wq);
  1240. }
  1241. /*
  1242. * Initialize NFS
  1243. */
  1244. static int __init init_nfs_fs(void)
  1245. {
  1246. int err;
  1247. err = nfsiod_start();
  1248. if (err)
  1249. goto out6;
  1250. err = nfs_fs_proc_init();
  1251. if (err)
  1252. goto out5;
  1253. err = nfs_init_nfspagecache();
  1254. if (err)
  1255. goto out4;
  1256. err = nfs_init_inodecache();
  1257. if (err)
  1258. goto out3;
  1259. err = nfs_init_readpagecache();
  1260. if (err)
  1261. goto out2;
  1262. err = nfs_init_writepagecache();
  1263. if (err)
  1264. goto out1;
  1265. err = nfs_init_directcache();
  1266. if (err)
  1267. goto out0;
  1268. #ifdef CONFIG_PROC_FS
  1269. rpc_proc_register(&nfs_rpcstat);
  1270. #endif
  1271. if ((err = register_nfs_fs()) != 0)
  1272. goto out;
  1273. return 0;
  1274. out:
  1275. #ifdef CONFIG_PROC_FS
  1276. rpc_proc_unregister("nfs");
  1277. #endif
  1278. nfs_destroy_directcache();
  1279. out0:
  1280. nfs_destroy_writepagecache();
  1281. out1:
  1282. nfs_destroy_readpagecache();
  1283. out2:
  1284. nfs_destroy_inodecache();
  1285. out3:
  1286. nfs_destroy_nfspagecache();
  1287. out4:
  1288. nfs_fs_proc_exit();
  1289. out5:
  1290. nfsiod_stop();
  1291. out6:
  1292. return err;
  1293. }
  1294. static void __exit exit_nfs_fs(void)
  1295. {
  1296. nfs_destroy_directcache();
  1297. nfs_destroy_writepagecache();
  1298. nfs_destroy_readpagecache();
  1299. nfs_destroy_inodecache();
  1300. nfs_destroy_nfspagecache();
  1301. #ifdef CONFIG_PROC_FS
  1302. rpc_proc_unregister("nfs");
  1303. #endif
  1304. unregister_nfs_fs();
  1305. nfs_fs_proc_exit();
  1306. nfsiod_stop();
  1307. }
  1308. /* Not quite true; I just maintain it */
  1309. MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
  1310. MODULE_LICENSE("GPL");
  1311. module_param(enable_ino64, bool, 0644);
  1312. module_init(init_nfs_fs)
  1313. module_exit(exit_nfs_fs)