inode.c 54 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975
  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/seq_file.h>
  33. #include <linux/mount.h>
  34. #include <linux/vfs.h>
  35. #include <linux/inet.h>
  36. #include <linux/nfs_xdr.h>
  37. #include <linux/slab.h>
  38. #include <linux/compat.h>
  39. #include <linux/freezer.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. #include "fscache.h"
  47. #include "pnfs.h"
  48. #include "nfs.h"
  49. #include "netns.h"
  50. #include "nfstrace.h"
  51. #define NFSDBG_FACILITY NFSDBG_VFS
  52. #define NFS_64_BIT_INODE_NUMBERS_ENABLED 1
  53. /* Default is to see 64-bit inode numbers */
  54. static bool enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED;
  55. static void nfs_invalidate_inode(struct inode *);
  56. static int nfs_update_inode(struct inode *, struct nfs_fattr *);
  57. static struct kmem_cache * nfs_inode_cachep;
  58. static inline unsigned long
  59. nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
  60. {
  61. return nfs_fileid_to_ino_t(fattr->fileid);
  62. }
  63. /**
  64. * nfs_wait_bit_killable - helper for functions that are sleeping on bit locks
  65. * @word: long word containing the bit lock
  66. */
  67. int nfs_wait_bit_killable(struct wait_bit_key *key)
  68. {
  69. if (fatal_signal_pending(current))
  70. return -ERESTARTSYS;
  71. freezable_schedule_unsafe();
  72. return 0;
  73. }
  74. EXPORT_SYMBOL_GPL(nfs_wait_bit_killable);
  75. /**
  76. * nfs_compat_user_ino64 - returns the user-visible inode number
  77. * @fileid: 64-bit fileid
  78. *
  79. * This function returns a 32-bit inode number if the boot parameter
  80. * nfs.enable_ino64 is zero.
  81. */
  82. u64 nfs_compat_user_ino64(u64 fileid)
  83. {
  84. #ifdef CONFIG_COMPAT
  85. compat_ulong_t ino;
  86. #else
  87. unsigned long ino;
  88. #endif
  89. if (enable_ino64)
  90. return fileid;
  91. ino = fileid;
  92. if (sizeof(ino) < sizeof(fileid))
  93. ino ^= fileid >> (sizeof(fileid)-sizeof(ino)) * 8;
  94. return ino;
  95. }
  96. int nfs_drop_inode(struct inode *inode)
  97. {
  98. return NFS_STALE(inode) || generic_drop_inode(inode);
  99. }
  100. EXPORT_SYMBOL_GPL(nfs_drop_inode);
  101. void nfs_clear_inode(struct inode *inode)
  102. {
  103. /*
  104. * The following should never happen...
  105. */
  106. WARN_ON_ONCE(nfs_have_writebacks(inode));
  107. WARN_ON_ONCE(!list_empty(&NFS_I(inode)->open_files));
  108. nfs_zap_acl_cache(inode);
  109. nfs_access_zap_cache(inode);
  110. nfs_fscache_clear_inode(inode);
  111. }
  112. EXPORT_SYMBOL_GPL(nfs_clear_inode);
  113. void nfs_evict_inode(struct inode *inode)
  114. {
  115. truncate_inode_pages_final(&inode->i_data);
  116. clear_inode(inode);
  117. nfs_clear_inode(inode);
  118. }
  119. /**
  120. * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
  121. */
  122. int nfs_sync_mapping(struct address_space *mapping)
  123. {
  124. int ret = 0;
  125. if (mapping->nrpages != 0) {
  126. unmap_mapping_range(mapping, 0, 0, 0);
  127. ret = nfs_wb_all(mapping->host);
  128. }
  129. return ret;
  130. }
  131. static void nfs_set_cache_invalid(struct inode *inode, unsigned long flags)
  132. {
  133. struct nfs_inode *nfsi = NFS_I(inode);
  134. if (inode->i_mapping->nrpages == 0)
  135. flags &= ~NFS_INO_INVALID_DATA;
  136. nfsi->cache_validity |= flags;
  137. if (flags & NFS_INO_INVALID_DATA)
  138. nfs_fscache_invalidate(inode);
  139. }
  140. /*
  141. * Invalidate the local caches
  142. */
  143. static void nfs_zap_caches_locked(struct inode *inode)
  144. {
  145. struct nfs_inode *nfsi = NFS_I(inode);
  146. int mode = inode->i_mode;
  147. nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
  148. nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
  149. nfsi->attrtimeo_timestamp = jiffies;
  150. memset(NFS_I(inode)->cookieverf, 0, sizeof(NFS_I(inode)->cookieverf));
  151. if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) {
  152. nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR
  153. | NFS_INO_INVALID_DATA
  154. | NFS_INO_INVALID_ACCESS
  155. | NFS_INO_INVALID_ACL
  156. | NFS_INO_REVAL_PAGECACHE);
  157. } else
  158. nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR
  159. | NFS_INO_INVALID_ACCESS
  160. | NFS_INO_INVALID_ACL
  161. | NFS_INO_REVAL_PAGECACHE);
  162. nfs_zap_label_cache_locked(nfsi);
  163. }
  164. void nfs_zap_caches(struct inode *inode)
  165. {
  166. spin_lock(&inode->i_lock);
  167. nfs_zap_caches_locked(inode);
  168. spin_unlock(&inode->i_lock);
  169. }
  170. EXPORT_SYMBOL_GPL(nfs_zap_caches);
  171. void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
  172. {
  173. if (mapping->nrpages != 0) {
  174. spin_lock(&inode->i_lock);
  175. nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
  176. spin_unlock(&inode->i_lock);
  177. }
  178. }
  179. void nfs_zap_acl_cache(struct inode *inode)
  180. {
  181. void (*clear_acl_cache)(struct inode *);
  182. clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
  183. if (clear_acl_cache != NULL)
  184. clear_acl_cache(inode);
  185. spin_lock(&inode->i_lock);
  186. NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
  187. spin_unlock(&inode->i_lock);
  188. }
  189. EXPORT_SYMBOL_GPL(nfs_zap_acl_cache);
  190. void nfs_invalidate_atime(struct inode *inode)
  191. {
  192. spin_lock(&inode->i_lock);
  193. nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
  194. spin_unlock(&inode->i_lock);
  195. }
  196. EXPORT_SYMBOL_GPL(nfs_invalidate_atime);
  197. /*
  198. * Invalidate, but do not unhash, the inode.
  199. * NB: must be called with inode->i_lock held!
  200. */
  201. static void nfs_invalidate_inode(struct inode *inode)
  202. {
  203. set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
  204. nfs_zap_caches_locked(inode);
  205. }
  206. struct nfs_find_desc {
  207. struct nfs_fh *fh;
  208. struct nfs_fattr *fattr;
  209. };
  210. /*
  211. * In NFSv3 we can have 64bit inode numbers. In order to support
  212. * this, and re-exported directories (also seen in NFSv2)
  213. * we are forced to allow 2 different inodes to have the same
  214. * i_ino.
  215. */
  216. static int
  217. nfs_find_actor(struct inode *inode, void *opaque)
  218. {
  219. struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
  220. struct nfs_fh *fh = desc->fh;
  221. struct nfs_fattr *fattr = desc->fattr;
  222. if (NFS_FILEID(inode) != fattr->fileid)
  223. return 0;
  224. if ((S_IFMT & inode->i_mode) != (S_IFMT & fattr->mode))
  225. return 0;
  226. if (nfs_compare_fh(NFS_FH(inode), fh))
  227. return 0;
  228. if (is_bad_inode(inode) || NFS_STALE(inode))
  229. return 0;
  230. return 1;
  231. }
  232. static int
  233. nfs_init_locked(struct inode *inode, void *opaque)
  234. {
  235. struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
  236. struct nfs_fattr *fattr = desc->fattr;
  237. set_nfs_fileid(inode, fattr->fileid);
  238. nfs_copy_fh(NFS_FH(inode), desc->fh);
  239. return 0;
  240. }
  241. #ifdef CONFIG_NFS_V4_SECURITY_LABEL
  242. static void nfs_clear_label_invalid(struct inode *inode)
  243. {
  244. spin_lock(&inode->i_lock);
  245. NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_LABEL;
  246. spin_unlock(&inode->i_lock);
  247. }
  248. void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
  249. struct nfs4_label *label)
  250. {
  251. int error;
  252. if (label == NULL)
  253. return;
  254. if ((fattr->valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL) && inode->i_security) {
  255. error = security_inode_notifysecctx(inode, label->label,
  256. label->len);
  257. if (error)
  258. printk(KERN_ERR "%s() %s %d "
  259. "security_inode_notifysecctx() %d\n",
  260. __func__,
  261. (char *)label->label,
  262. label->len, error);
  263. nfs_clear_label_invalid(inode);
  264. }
  265. }
  266. struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags)
  267. {
  268. struct nfs4_label *label = NULL;
  269. int minor_version = server->nfs_client->cl_minorversion;
  270. if (minor_version < 2)
  271. return label;
  272. if (!(server->caps & NFS_CAP_SECURITY_LABEL))
  273. return label;
  274. label = kzalloc(sizeof(struct nfs4_label), flags);
  275. if (label == NULL)
  276. return ERR_PTR(-ENOMEM);
  277. label->label = kzalloc(NFS4_MAXLABELLEN, flags);
  278. if (label->label == NULL) {
  279. kfree(label);
  280. return ERR_PTR(-ENOMEM);
  281. }
  282. label->len = NFS4_MAXLABELLEN;
  283. return label;
  284. }
  285. EXPORT_SYMBOL_GPL(nfs4_label_alloc);
  286. #else
  287. void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr,
  288. struct nfs4_label *label)
  289. {
  290. }
  291. #endif
  292. EXPORT_SYMBOL_GPL(nfs_setsecurity);
  293. /*
  294. * This is our front-end to iget that looks up inodes by file handle
  295. * instead of inode number.
  296. */
  297. struct inode *
  298. nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr, struct nfs4_label *label)
  299. {
  300. struct nfs_find_desc desc = {
  301. .fh = fh,
  302. .fattr = fattr
  303. };
  304. struct inode *inode = ERR_PTR(-ENOENT);
  305. unsigned long hash;
  306. nfs_attr_check_mountpoint(sb, fattr);
  307. if (nfs_attr_use_mounted_on_fileid(fattr))
  308. fattr->fileid = fattr->mounted_on_fileid;
  309. else if ((fattr->valid & NFS_ATTR_FATTR_FILEID) == 0)
  310. goto out_no_inode;
  311. if ((fattr->valid & NFS_ATTR_FATTR_TYPE) == 0)
  312. goto out_no_inode;
  313. hash = nfs_fattr_to_ino_t(fattr);
  314. inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
  315. if (inode == NULL) {
  316. inode = ERR_PTR(-ENOMEM);
  317. goto out_no_inode;
  318. }
  319. if (inode->i_state & I_NEW) {
  320. struct nfs_inode *nfsi = NFS_I(inode);
  321. unsigned long now = jiffies;
  322. /* We set i_ino for the few things that still rely on it,
  323. * such as stat(2) */
  324. inode->i_ino = hash;
  325. /* We can't support update_atime(), since the server will reset it */
  326. inode->i_flags |= S_NOATIME|S_NOCMTIME;
  327. inode->i_mode = fattr->mode;
  328. if ((fattr->valid & NFS_ATTR_FATTR_MODE) == 0
  329. && nfs_server_capable(inode, NFS_CAP_MODE))
  330. nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
  331. /* Why so? Because we want revalidate for devices/FIFOs, and
  332. * that's precisely what we have in nfs_file_inode_operations.
  333. */
  334. inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
  335. if (S_ISREG(inode->i_mode)) {
  336. inode->i_fop = NFS_SB(sb)->nfs_client->rpc_ops->file_ops;
  337. inode->i_data.a_ops = &nfs_file_aops;
  338. } else if (S_ISDIR(inode->i_mode)) {
  339. inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
  340. inode->i_fop = &nfs_dir_operations;
  341. inode->i_data.a_ops = &nfs_dir_aops;
  342. /* Deal with crossing mountpoints */
  343. if (fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT ||
  344. fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
  345. if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
  346. inode->i_op = &nfs_referral_inode_operations;
  347. else
  348. inode->i_op = &nfs_mountpoint_inode_operations;
  349. inode->i_fop = NULL;
  350. inode->i_flags |= S_AUTOMOUNT;
  351. }
  352. } else if (S_ISLNK(inode->i_mode))
  353. inode->i_op = &nfs_symlink_inode_operations;
  354. else
  355. init_special_inode(inode, inode->i_mode, fattr->rdev);
  356. memset(&inode->i_atime, 0, sizeof(inode->i_atime));
  357. memset(&inode->i_mtime, 0, sizeof(inode->i_mtime));
  358. memset(&inode->i_ctime, 0, sizeof(inode->i_ctime));
  359. inode->i_version = 0;
  360. inode->i_size = 0;
  361. clear_nlink(inode);
  362. inode->i_uid = make_kuid(&init_user_ns, -2);
  363. inode->i_gid = make_kgid(&init_user_ns, -2);
  364. inode->i_blocks = 0;
  365. memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
  366. nfsi->write_io = 0;
  367. nfsi->read_io = 0;
  368. nfsi->read_cache_jiffies = fattr->time_start;
  369. nfsi->attr_gencount = fattr->gencount;
  370. if (fattr->valid & NFS_ATTR_FATTR_ATIME)
  371. inode->i_atime = fattr->atime;
  372. else if (nfs_server_capable(inode, NFS_CAP_ATIME))
  373. nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
  374. if (fattr->valid & NFS_ATTR_FATTR_MTIME)
  375. inode->i_mtime = fattr->mtime;
  376. else if (nfs_server_capable(inode, NFS_CAP_MTIME))
  377. nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
  378. if (fattr->valid & NFS_ATTR_FATTR_CTIME)
  379. inode->i_ctime = fattr->ctime;
  380. else if (nfs_server_capable(inode, NFS_CAP_CTIME))
  381. nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
  382. if (fattr->valid & NFS_ATTR_FATTR_CHANGE)
  383. inode->i_version = fattr->change_attr;
  384. else if (nfs_server_capable(inode, NFS_CAP_CHANGE_ATTR))
  385. nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
  386. if (fattr->valid & NFS_ATTR_FATTR_SIZE)
  387. inode->i_size = nfs_size_to_loff_t(fattr->size);
  388. else
  389. nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR
  390. | NFS_INO_REVAL_PAGECACHE);
  391. if (fattr->valid & NFS_ATTR_FATTR_NLINK)
  392. set_nlink(inode, fattr->nlink);
  393. else if (nfs_server_capable(inode, NFS_CAP_NLINK))
  394. nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
  395. if (fattr->valid & NFS_ATTR_FATTR_OWNER)
  396. inode->i_uid = fattr->uid;
  397. else if (nfs_server_capable(inode, NFS_CAP_OWNER))
  398. nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
  399. if (fattr->valid & NFS_ATTR_FATTR_GROUP)
  400. inode->i_gid = fattr->gid;
  401. else if (nfs_server_capable(inode, NFS_CAP_OWNER_GROUP))
  402. nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR);
  403. if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
  404. inode->i_blocks = fattr->du.nfs2.blocks;
  405. if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
  406. /*
  407. * report the blocks in 512byte units
  408. */
  409. inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
  410. }
  411. nfs_setsecurity(inode, fattr, label);
  412. nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
  413. nfsi->attrtimeo_timestamp = now;
  414. nfsi->access_cache = RB_ROOT;
  415. nfs_fscache_init_inode(inode);
  416. unlock_new_inode(inode);
  417. } else
  418. nfs_refresh_inode(inode, fattr);
  419. dprintk("NFS: nfs_fhget(%s/%Lu fh_crc=0x%08x ct=%d)\n",
  420. inode->i_sb->s_id,
  421. (unsigned long long)NFS_FILEID(inode),
  422. nfs_display_fhandle_hash(fh),
  423. atomic_read(&inode->i_count));
  424. out:
  425. return inode;
  426. out_no_inode:
  427. dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
  428. goto out;
  429. }
  430. EXPORT_SYMBOL_GPL(nfs_fhget);
  431. #define NFS_VALID_ATTRS (ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_SIZE|ATTR_ATIME|ATTR_ATIME_SET|ATTR_MTIME|ATTR_MTIME_SET|ATTR_FILE|ATTR_OPEN)
  432. int
  433. nfs_setattr(struct dentry *dentry, struct iattr *attr)
  434. {
  435. struct inode *inode = dentry->d_inode;
  436. struct nfs_fattr *fattr;
  437. int error = -ENOMEM;
  438. nfs_inc_stats(inode, NFSIOS_VFSSETATTR);
  439. /* skip mode change if it's just for clearing setuid/setgid */
  440. if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
  441. attr->ia_valid &= ~ATTR_MODE;
  442. if (attr->ia_valid & ATTR_SIZE) {
  443. loff_t i_size;
  444. BUG_ON(!S_ISREG(inode->i_mode));
  445. i_size = i_size_read(inode);
  446. if (attr->ia_size == i_size)
  447. attr->ia_valid &= ~ATTR_SIZE;
  448. else if (attr->ia_size < i_size && IS_SWAPFILE(inode))
  449. return -ETXTBSY;
  450. }
  451. /* Optimization: if the end result is no change, don't RPC */
  452. attr->ia_valid &= NFS_VALID_ATTRS;
  453. if ((attr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0)
  454. return 0;
  455. trace_nfs_setattr_enter(inode);
  456. /* Write all dirty data */
  457. if (S_ISREG(inode->i_mode)) {
  458. nfs_inode_dio_wait(inode);
  459. nfs_wb_all(inode);
  460. }
  461. fattr = nfs_alloc_fattr();
  462. if (fattr == NULL)
  463. goto out;
  464. /*
  465. * Return any delegations if we're going to change ACLs
  466. */
  467. if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0)
  468. NFS_PROTO(inode)->return_delegation(inode);
  469. error = NFS_PROTO(inode)->setattr(dentry, fattr, attr);
  470. if (error == 0)
  471. error = nfs_refresh_inode(inode, fattr);
  472. nfs_free_fattr(fattr);
  473. out:
  474. trace_nfs_setattr_exit(inode, error);
  475. return error;
  476. }
  477. EXPORT_SYMBOL_GPL(nfs_setattr);
  478. /**
  479. * nfs_vmtruncate - unmap mappings "freed" by truncate() syscall
  480. * @inode: inode of the file used
  481. * @offset: file offset to start truncating
  482. *
  483. * This is a copy of the common vmtruncate, but with the locking
  484. * corrected to take into account the fact that NFS requires
  485. * inode->i_size to be updated under the inode->i_lock.
  486. */
  487. static int nfs_vmtruncate(struct inode * inode, loff_t offset)
  488. {
  489. int err;
  490. err = inode_newsize_ok(inode, offset);
  491. if (err)
  492. goto out;
  493. spin_lock(&inode->i_lock);
  494. i_size_write(inode, offset);
  495. /* Optimisation */
  496. if (offset == 0)
  497. NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_DATA;
  498. spin_unlock(&inode->i_lock);
  499. truncate_pagecache(inode, offset);
  500. out:
  501. return err;
  502. }
  503. /**
  504. * nfs_setattr_update_inode - Update inode metadata after a setattr call.
  505. * @inode: pointer to struct inode
  506. * @attr: pointer to struct iattr
  507. *
  508. * Note: we do this in the *proc.c in order to ensure that
  509. * it works for things like exclusive creates too.
  510. */
  511. void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr)
  512. {
  513. if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) {
  514. spin_lock(&inode->i_lock);
  515. if ((attr->ia_valid & ATTR_MODE) != 0) {
  516. int mode = attr->ia_mode & S_IALLUGO;
  517. mode |= inode->i_mode & ~S_IALLUGO;
  518. inode->i_mode = mode;
  519. }
  520. if ((attr->ia_valid & ATTR_UID) != 0)
  521. inode->i_uid = attr->ia_uid;
  522. if ((attr->ia_valid & ATTR_GID) != 0)
  523. inode->i_gid = attr->ia_gid;
  524. nfs_set_cache_invalid(inode, NFS_INO_INVALID_ACCESS
  525. | NFS_INO_INVALID_ACL);
  526. spin_unlock(&inode->i_lock);
  527. }
  528. if ((attr->ia_valid & ATTR_SIZE) != 0) {
  529. nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
  530. nfs_vmtruncate(inode, attr->ia_size);
  531. }
  532. }
  533. EXPORT_SYMBOL_GPL(nfs_setattr_update_inode);
  534. static void nfs_request_parent_use_readdirplus(struct dentry *dentry)
  535. {
  536. struct dentry *parent;
  537. parent = dget_parent(dentry);
  538. nfs_force_use_readdirplus(parent->d_inode);
  539. dput(parent);
  540. }
  541. static bool nfs_need_revalidate_inode(struct inode *inode)
  542. {
  543. if (NFS_I(inode)->cache_validity &
  544. (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL))
  545. return true;
  546. if (nfs_attribute_cache_expired(inode))
  547. return true;
  548. return false;
  549. }
  550. int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
  551. {
  552. struct inode *inode = dentry->d_inode;
  553. int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME;
  554. int err = 0;
  555. trace_nfs_getattr_enter(inode);
  556. /* Flush out writes to the server in order to update c/mtime. */
  557. if (S_ISREG(inode->i_mode)) {
  558. nfs_inode_dio_wait(inode);
  559. err = filemap_write_and_wait(inode->i_mapping);
  560. if (err)
  561. goto out;
  562. }
  563. /*
  564. * We may force a getattr if the user cares about atime.
  565. *
  566. * Note that we only have to check the vfsmount flags here:
  567. * - NFS always sets S_NOATIME by so checking it would give a
  568. * bogus result
  569. * - NFS never sets MS_NOATIME or MS_NODIRATIME so there is
  570. * no point in checking those.
  571. */
  572. if ((mnt->mnt_flags & MNT_NOATIME) ||
  573. ((mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
  574. need_atime = 0;
  575. if (need_atime || nfs_need_revalidate_inode(inode)) {
  576. struct nfs_server *server = NFS_SERVER(inode);
  577. if (server->caps & NFS_CAP_READDIRPLUS)
  578. nfs_request_parent_use_readdirplus(dentry);
  579. err = __nfs_revalidate_inode(server, inode);
  580. }
  581. if (!err) {
  582. generic_fillattr(inode, stat);
  583. stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
  584. }
  585. out:
  586. trace_nfs_getattr_exit(inode, err);
  587. return err;
  588. }
  589. EXPORT_SYMBOL_GPL(nfs_getattr);
  590. static void nfs_init_lock_context(struct nfs_lock_context *l_ctx)
  591. {
  592. atomic_set(&l_ctx->count, 1);
  593. l_ctx->lockowner.l_owner = current->files;
  594. l_ctx->lockowner.l_pid = current->tgid;
  595. INIT_LIST_HEAD(&l_ctx->list);
  596. nfs_iocounter_init(&l_ctx->io_count);
  597. }
  598. static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context *ctx)
  599. {
  600. struct nfs_lock_context *head = &ctx->lock_context;
  601. struct nfs_lock_context *pos = head;
  602. do {
  603. if (pos->lockowner.l_owner != current->files)
  604. continue;
  605. if (pos->lockowner.l_pid != current->tgid)
  606. continue;
  607. atomic_inc(&pos->count);
  608. return pos;
  609. } while ((pos = list_entry(pos->list.next, typeof(*pos), list)) != head);
  610. return NULL;
  611. }
  612. struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx)
  613. {
  614. struct nfs_lock_context *res, *new = NULL;
  615. struct inode *inode = ctx->dentry->d_inode;
  616. spin_lock(&inode->i_lock);
  617. res = __nfs_find_lock_context(ctx);
  618. if (res == NULL) {
  619. spin_unlock(&inode->i_lock);
  620. new = kmalloc(sizeof(*new), GFP_KERNEL);
  621. if (new == NULL)
  622. return ERR_PTR(-ENOMEM);
  623. nfs_init_lock_context(new);
  624. spin_lock(&inode->i_lock);
  625. res = __nfs_find_lock_context(ctx);
  626. if (res == NULL) {
  627. list_add_tail(&new->list, &ctx->lock_context.list);
  628. new->open_context = ctx;
  629. res = new;
  630. new = NULL;
  631. }
  632. }
  633. spin_unlock(&inode->i_lock);
  634. kfree(new);
  635. return res;
  636. }
  637. EXPORT_SYMBOL_GPL(nfs_get_lock_context);
  638. void nfs_put_lock_context(struct nfs_lock_context *l_ctx)
  639. {
  640. struct nfs_open_context *ctx = l_ctx->open_context;
  641. struct inode *inode = ctx->dentry->d_inode;
  642. if (!atomic_dec_and_lock(&l_ctx->count, &inode->i_lock))
  643. return;
  644. list_del(&l_ctx->list);
  645. spin_unlock(&inode->i_lock);
  646. kfree(l_ctx);
  647. }
  648. EXPORT_SYMBOL_GPL(nfs_put_lock_context);
  649. /**
  650. * nfs_close_context - Common close_context() routine NFSv2/v3
  651. * @ctx: pointer to context
  652. * @is_sync: is this a synchronous close
  653. *
  654. * always ensure that the attributes are up to date if we're mounted
  655. * with close-to-open semantics
  656. */
  657. void nfs_close_context(struct nfs_open_context *ctx, int is_sync)
  658. {
  659. struct inode *inode;
  660. struct nfs_server *server;
  661. if (!(ctx->mode & FMODE_WRITE))
  662. return;
  663. if (!is_sync)
  664. return;
  665. inode = ctx->dentry->d_inode;
  666. if (!list_empty(&NFS_I(inode)->open_files))
  667. return;
  668. server = NFS_SERVER(inode);
  669. if (server->flags & NFS_MOUNT_NOCTO)
  670. return;
  671. nfs_revalidate_inode(server, inode);
  672. }
  673. EXPORT_SYMBOL_GPL(nfs_close_context);
  674. struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, fmode_t f_mode)
  675. {
  676. struct nfs_open_context *ctx;
  677. struct rpc_cred *cred = rpc_lookup_cred();
  678. if (IS_ERR(cred))
  679. return ERR_CAST(cred);
  680. ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
  681. if (!ctx) {
  682. put_rpccred(cred);
  683. return ERR_PTR(-ENOMEM);
  684. }
  685. nfs_sb_active(dentry->d_sb);
  686. ctx->dentry = dget(dentry);
  687. ctx->cred = cred;
  688. ctx->state = NULL;
  689. ctx->mode = f_mode;
  690. ctx->flags = 0;
  691. ctx->error = 0;
  692. nfs_init_lock_context(&ctx->lock_context);
  693. ctx->lock_context.open_context = ctx;
  694. INIT_LIST_HEAD(&ctx->list);
  695. ctx->mdsthreshold = NULL;
  696. return ctx;
  697. }
  698. EXPORT_SYMBOL_GPL(alloc_nfs_open_context);
  699. struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
  700. {
  701. if (ctx != NULL)
  702. atomic_inc(&ctx->lock_context.count);
  703. return ctx;
  704. }
  705. EXPORT_SYMBOL_GPL(get_nfs_open_context);
  706. static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
  707. {
  708. struct inode *inode = ctx->dentry->d_inode;
  709. struct super_block *sb = ctx->dentry->d_sb;
  710. if (!list_empty(&ctx->list)) {
  711. if (!atomic_dec_and_lock(&ctx->lock_context.count, &inode->i_lock))
  712. return;
  713. list_del(&ctx->list);
  714. spin_unlock(&inode->i_lock);
  715. } else if (!atomic_dec_and_test(&ctx->lock_context.count))
  716. return;
  717. if (inode != NULL)
  718. NFS_PROTO(inode)->close_context(ctx, is_sync);
  719. if (ctx->cred != NULL)
  720. put_rpccred(ctx->cred);
  721. dput(ctx->dentry);
  722. nfs_sb_deactive(sb);
  723. kfree(ctx->mdsthreshold);
  724. kfree(ctx);
  725. }
  726. void put_nfs_open_context(struct nfs_open_context *ctx)
  727. {
  728. __put_nfs_open_context(ctx, 0);
  729. }
  730. EXPORT_SYMBOL_GPL(put_nfs_open_context);
  731. /*
  732. * Ensure that mmap has a recent RPC credential for use when writing out
  733. * shared pages
  734. */
  735. void nfs_inode_attach_open_context(struct nfs_open_context *ctx)
  736. {
  737. struct inode *inode = ctx->dentry->d_inode;
  738. struct nfs_inode *nfsi = NFS_I(inode);
  739. spin_lock(&inode->i_lock);
  740. list_add(&ctx->list, &nfsi->open_files);
  741. spin_unlock(&inode->i_lock);
  742. }
  743. EXPORT_SYMBOL_GPL(nfs_inode_attach_open_context);
  744. void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
  745. {
  746. filp->private_data = get_nfs_open_context(ctx);
  747. if (list_empty(&ctx->list))
  748. nfs_inode_attach_open_context(ctx);
  749. }
  750. EXPORT_SYMBOL_GPL(nfs_file_set_open_context);
  751. /*
  752. * Given an inode, search for an open context with the desired characteristics
  753. */
  754. struct nfs_open_context *nfs_find_open_context(struct inode *inode, struct rpc_cred *cred, fmode_t mode)
  755. {
  756. struct nfs_inode *nfsi = NFS_I(inode);
  757. struct nfs_open_context *pos, *ctx = NULL;
  758. spin_lock(&inode->i_lock);
  759. list_for_each_entry(pos, &nfsi->open_files, list) {
  760. if (cred != NULL && pos->cred != cred)
  761. continue;
  762. if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode)
  763. continue;
  764. ctx = get_nfs_open_context(pos);
  765. break;
  766. }
  767. spin_unlock(&inode->i_lock);
  768. return ctx;
  769. }
  770. static void nfs_file_clear_open_context(struct file *filp)
  771. {
  772. struct nfs_open_context *ctx = nfs_file_open_context(filp);
  773. if (ctx) {
  774. struct inode *inode = ctx->dentry->d_inode;
  775. filp->private_data = NULL;
  776. spin_lock(&inode->i_lock);
  777. list_move_tail(&ctx->list, &NFS_I(inode)->open_files);
  778. spin_unlock(&inode->i_lock);
  779. __put_nfs_open_context(ctx, filp->f_flags & O_DIRECT ? 0 : 1);
  780. }
  781. }
  782. /*
  783. * These allocate and release file read/write context information.
  784. */
  785. int nfs_open(struct inode *inode, struct file *filp)
  786. {
  787. struct nfs_open_context *ctx;
  788. ctx = alloc_nfs_open_context(filp->f_path.dentry, filp->f_mode);
  789. if (IS_ERR(ctx))
  790. return PTR_ERR(ctx);
  791. nfs_file_set_open_context(filp, ctx);
  792. put_nfs_open_context(ctx);
  793. nfs_fscache_open_file(inode, filp);
  794. return 0;
  795. }
  796. int nfs_release(struct inode *inode, struct file *filp)
  797. {
  798. nfs_file_clear_open_context(filp);
  799. return 0;
  800. }
  801. /*
  802. * This function is called whenever some part of NFS notices that
  803. * the cached attributes have to be refreshed.
  804. */
  805. int
  806. __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
  807. {
  808. int status = -ESTALE;
  809. struct nfs4_label *label = NULL;
  810. struct nfs_fattr *fattr = NULL;
  811. struct nfs_inode *nfsi = NFS_I(inode);
  812. dfprintk(PAGECACHE, "NFS: revalidating (%s/%Lu)\n",
  813. inode->i_sb->s_id, (unsigned long long)NFS_FILEID(inode));
  814. trace_nfs_revalidate_inode_enter(inode);
  815. if (is_bad_inode(inode))
  816. goto out;
  817. if (NFS_STALE(inode))
  818. goto out;
  819. status = -ENOMEM;
  820. fattr = nfs_alloc_fattr();
  821. if (fattr == NULL)
  822. goto out;
  823. nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
  824. label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
  825. if (IS_ERR(label)) {
  826. status = PTR_ERR(label);
  827. goto out;
  828. }
  829. status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, label);
  830. if (status != 0) {
  831. dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) getattr failed, error=%d\n",
  832. inode->i_sb->s_id,
  833. (unsigned long long)NFS_FILEID(inode), status);
  834. if (status == -ESTALE) {
  835. nfs_zap_caches(inode);
  836. if (!S_ISDIR(inode->i_mode))
  837. set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
  838. }
  839. goto err_out;
  840. }
  841. status = nfs_refresh_inode(inode, fattr);
  842. if (status) {
  843. dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) refresh failed, error=%d\n",
  844. inode->i_sb->s_id,
  845. (unsigned long long)NFS_FILEID(inode), status);
  846. goto err_out;
  847. }
  848. if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
  849. nfs_zap_acl_cache(inode);
  850. nfs_setsecurity(inode, fattr, label);
  851. dfprintk(PAGECACHE, "NFS: (%s/%Lu) revalidation complete\n",
  852. inode->i_sb->s_id,
  853. (unsigned long long)NFS_FILEID(inode));
  854. err_out:
  855. nfs4_label_free(label);
  856. out:
  857. nfs_free_fattr(fattr);
  858. trace_nfs_revalidate_inode_exit(inode, status);
  859. return status;
  860. }
  861. int nfs_attribute_timeout(struct inode *inode)
  862. {
  863. struct nfs_inode *nfsi = NFS_I(inode);
  864. return !time_in_range_open(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo);
  865. }
  866. int nfs_attribute_cache_expired(struct inode *inode)
  867. {
  868. if (nfs_have_delegated_attributes(inode))
  869. return 0;
  870. return nfs_attribute_timeout(inode);
  871. }
  872. /**
  873. * nfs_revalidate_inode - Revalidate the inode attributes
  874. * @server - pointer to nfs_server struct
  875. * @inode - pointer to inode struct
  876. *
  877. * Updates inode attribute information by retrieving the data from the server.
  878. */
  879. int nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
  880. {
  881. if (!nfs_need_revalidate_inode(inode))
  882. return NFS_STALE(inode) ? -ESTALE : 0;
  883. return __nfs_revalidate_inode(server, inode);
  884. }
  885. EXPORT_SYMBOL_GPL(nfs_revalidate_inode);
  886. int nfs_revalidate_inode_rcu(struct nfs_server *server, struct inode *inode)
  887. {
  888. if (!(NFS_I(inode)->cache_validity &
  889. (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_LABEL))
  890. && !nfs_attribute_cache_expired(inode))
  891. return NFS_STALE(inode) ? -ESTALE : 0;
  892. return -ECHILD;
  893. }
  894. static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
  895. {
  896. struct nfs_inode *nfsi = NFS_I(inode);
  897. int ret;
  898. if (mapping->nrpages != 0) {
  899. if (S_ISREG(inode->i_mode)) {
  900. ret = nfs_sync_mapping(mapping);
  901. if (ret < 0)
  902. return ret;
  903. }
  904. ret = invalidate_inode_pages2(mapping);
  905. if (ret < 0)
  906. return ret;
  907. }
  908. if (S_ISDIR(inode->i_mode)) {
  909. spin_lock(&inode->i_lock);
  910. memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
  911. spin_unlock(&inode->i_lock);
  912. }
  913. nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
  914. nfs_fscache_wait_on_invalidate(inode);
  915. dfprintk(PAGECACHE, "NFS: (%s/%Lu) data cache invalidated\n",
  916. inode->i_sb->s_id,
  917. (unsigned long long)NFS_FILEID(inode));
  918. return 0;
  919. }
  920. static bool nfs_mapping_need_revalidate_inode(struct inode *inode)
  921. {
  922. if (nfs_have_delegated_attributes(inode))
  923. return false;
  924. return (NFS_I(inode)->cache_validity & NFS_INO_REVAL_PAGECACHE)
  925. || nfs_attribute_timeout(inode)
  926. || NFS_STALE(inode);
  927. }
  928. /**
  929. * nfs_revalidate_mapping - Revalidate the pagecache
  930. * @inode - pointer to host inode
  931. * @mapping - pointer to mapping
  932. */
  933. int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
  934. {
  935. struct nfs_inode *nfsi = NFS_I(inode);
  936. unsigned long *bitlock = &nfsi->flags;
  937. int ret = 0;
  938. /* swapfiles are not supposed to be shared. */
  939. if (IS_SWAPFILE(inode))
  940. goto out;
  941. if (nfs_mapping_need_revalidate_inode(inode)) {
  942. ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
  943. if (ret < 0)
  944. goto out;
  945. }
  946. /*
  947. * We must clear NFS_INO_INVALID_DATA first to ensure that
  948. * invalidations that come in while we're shooting down the mappings
  949. * are respected. But, that leaves a race window where one revalidator
  950. * can clear the flag, and then another checks it before the mapping
  951. * gets invalidated. Fix that by serializing access to this part of
  952. * the function.
  953. *
  954. * At the same time, we need to allow other tasks to see whether we
  955. * might be in the middle of invalidating the pages, so we only set
  956. * the bit lock here if it looks like we're going to be doing that.
  957. */
  958. for (;;) {
  959. ret = wait_on_bit_action(bitlock, NFS_INO_INVALIDATING,
  960. nfs_wait_bit_killable, TASK_KILLABLE);
  961. if (ret)
  962. goto out;
  963. spin_lock(&inode->i_lock);
  964. if (test_bit(NFS_INO_INVALIDATING, bitlock)) {
  965. spin_unlock(&inode->i_lock);
  966. continue;
  967. }
  968. if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
  969. break;
  970. spin_unlock(&inode->i_lock);
  971. goto out;
  972. }
  973. set_bit(NFS_INO_INVALIDATING, bitlock);
  974. smp_wmb();
  975. nfsi->cache_validity &= ~NFS_INO_INVALID_DATA;
  976. spin_unlock(&inode->i_lock);
  977. trace_nfs_invalidate_mapping_enter(inode);
  978. ret = nfs_invalidate_mapping(inode, mapping);
  979. trace_nfs_invalidate_mapping_exit(inode, ret);
  980. clear_bit_unlock(NFS_INO_INVALIDATING, bitlock);
  981. smp_mb__after_atomic();
  982. wake_up_bit(bitlock, NFS_INO_INVALIDATING);
  983. out:
  984. return ret;
  985. }
  986. static unsigned long nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
  987. {
  988. struct nfs_inode *nfsi = NFS_I(inode);
  989. unsigned long ret = 0;
  990. if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE)
  991. && (fattr->valid & NFS_ATTR_FATTR_CHANGE)
  992. && inode->i_version == fattr->pre_change_attr) {
  993. inode->i_version = fattr->change_attr;
  994. if (S_ISDIR(inode->i_mode))
  995. nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
  996. ret |= NFS_INO_INVALID_ATTR;
  997. }
  998. /* If we have atomic WCC data, we may update some attributes */
  999. if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME)
  1000. && (fattr->valid & NFS_ATTR_FATTR_CTIME)
  1001. && timespec_equal(&inode->i_ctime, &fattr->pre_ctime)) {
  1002. memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
  1003. ret |= NFS_INO_INVALID_ATTR;
  1004. }
  1005. if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME)
  1006. && (fattr->valid & NFS_ATTR_FATTR_MTIME)
  1007. && timespec_equal(&inode->i_mtime, &fattr->pre_mtime)) {
  1008. memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
  1009. if (S_ISDIR(inode->i_mode))
  1010. nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
  1011. ret |= NFS_INO_INVALID_ATTR;
  1012. }
  1013. if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE)
  1014. && (fattr->valid & NFS_ATTR_FATTR_SIZE)
  1015. && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size)
  1016. && nfsi->nrequests == 0) {
  1017. i_size_write(inode, nfs_size_to_loff_t(fattr->size));
  1018. ret |= NFS_INO_INVALID_ATTR;
  1019. }
  1020. return ret;
  1021. }
  1022. /**
  1023. * nfs_check_inode_attributes - verify consistency of the inode attribute cache
  1024. * @inode - pointer to inode
  1025. * @fattr - updated attributes
  1026. *
  1027. * Verifies the attribute cache. If we have just changed the attributes,
  1028. * so that fattr carries weak cache consistency data, then it may
  1029. * also update the ctime/mtime/change_attribute.
  1030. */
  1031. static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
  1032. {
  1033. struct nfs_inode *nfsi = NFS_I(inode);
  1034. loff_t cur_size, new_isize;
  1035. unsigned long invalid = 0;
  1036. if (nfs_have_delegated_attributes(inode))
  1037. return 0;
  1038. /* Has the inode gone and changed behind our back? */
  1039. if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid)
  1040. return -EIO;
  1041. if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT))
  1042. return -EIO;
  1043. if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
  1044. inode->i_version != fattr->change_attr)
  1045. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
  1046. /* Verify a few of the more important attributes */
  1047. if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec_equal(&inode->i_mtime, &fattr->mtime))
  1048. invalid |= NFS_INO_INVALID_ATTR;
  1049. if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
  1050. cur_size = i_size_read(inode);
  1051. new_isize = nfs_size_to_loff_t(fattr->size);
  1052. if (cur_size != new_isize && nfsi->nrequests == 0)
  1053. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
  1054. }
  1055. /* Have any file permissions changed? */
  1056. if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO))
  1057. invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
  1058. if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && !uid_eq(inode->i_uid, fattr->uid))
  1059. invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
  1060. if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && !gid_eq(inode->i_gid, fattr->gid))
  1061. invalid |= NFS_INO_INVALID_ATTR | NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL;
  1062. /* Has the link count changed? */
  1063. if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink)
  1064. invalid |= NFS_INO_INVALID_ATTR;
  1065. if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec_equal(&inode->i_atime, &fattr->atime))
  1066. invalid |= NFS_INO_INVALID_ATIME;
  1067. if (invalid != 0)
  1068. nfs_set_cache_invalid(inode, invalid);
  1069. nfsi->read_cache_jiffies = fattr->time_start;
  1070. return 0;
  1071. }
  1072. static int nfs_ctime_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
  1073. {
  1074. if (!(fattr->valid & NFS_ATTR_FATTR_CTIME))
  1075. return 0;
  1076. return timespec_compare(&fattr->ctime, &inode->i_ctime) > 0;
  1077. }
  1078. static int nfs_size_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
  1079. {
  1080. if (!(fattr->valid & NFS_ATTR_FATTR_SIZE))
  1081. return 0;
  1082. return nfs_size_to_loff_t(fattr->size) > i_size_read(inode);
  1083. }
  1084. static atomic_long_t nfs_attr_generation_counter;
  1085. static unsigned long nfs_read_attr_generation_counter(void)
  1086. {
  1087. return atomic_long_read(&nfs_attr_generation_counter);
  1088. }
  1089. unsigned long nfs_inc_attr_generation_counter(void)
  1090. {
  1091. return atomic_long_inc_return(&nfs_attr_generation_counter);
  1092. }
  1093. void nfs_fattr_init(struct nfs_fattr *fattr)
  1094. {
  1095. fattr->valid = 0;
  1096. fattr->time_start = jiffies;
  1097. fattr->gencount = nfs_inc_attr_generation_counter();
  1098. fattr->owner_name = NULL;
  1099. fattr->group_name = NULL;
  1100. }
  1101. EXPORT_SYMBOL_GPL(nfs_fattr_init);
  1102. struct nfs_fattr *nfs_alloc_fattr(void)
  1103. {
  1104. struct nfs_fattr *fattr;
  1105. fattr = kmalloc(sizeof(*fattr), GFP_NOFS);
  1106. if (fattr != NULL)
  1107. nfs_fattr_init(fattr);
  1108. return fattr;
  1109. }
  1110. EXPORT_SYMBOL_GPL(nfs_alloc_fattr);
  1111. struct nfs_fh *nfs_alloc_fhandle(void)
  1112. {
  1113. struct nfs_fh *fh;
  1114. fh = kmalloc(sizeof(struct nfs_fh), GFP_NOFS);
  1115. if (fh != NULL)
  1116. fh->size = 0;
  1117. return fh;
  1118. }
  1119. EXPORT_SYMBOL_GPL(nfs_alloc_fhandle);
  1120. #ifdef NFS_DEBUG
  1121. /*
  1122. * _nfs_display_fhandle_hash - calculate the crc32 hash for the filehandle
  1123. * in the same way that wireshark does
  1124. *
  1125. * @fh: file handle
  1126. *
  1127. * For debugging only.
  1128. */
  1129. u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh)
  1130. {
  1131. /* wireshark uses 32-bit AUTODIN crc and does a bitwise
  1132. * not on the result */
  1133. return nfs_fhandle_hash(fh);
  1134. }
  1135. EXPORT_SYMBOL_GPL(_nfs_display_fhandle_hash);
  1136. /*
  1137. * _nfs_display_fhandle - display an NFS file handle on the console
  1138. *
  1139. * @fh: file handle to display
  1140. * @caption: display caption
  1141. *
  1142. * For debugging only.
  1143. */
  1144. void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption)
  1145. {
  1146. unsigned short i;
  1147. if (fh == NULL || fh->size == 0) {
  1148. printk(KERN_DEFAULT "%s at %p is empty\n", caption, fh);
  1149. return;
  1150. }
  1151. printk(KERN_DEFAULT "%s at %p is %u bytes, crc: 0x%08x:\n",
  1152. caption, fh, fh->size, _nfs_display_fhandle_hash(fh));
  1153. for (i = 0; i < fh->size; i += 16) {
  1154. __be32 *pos = (__be32 *)&fh->data[i];
  1155. switch ((fh->size - i - 1) >> 2) {
  1156. case 0:
  1157. printk(KERN_DEFAULT " %08x\n",
  1158. be32_to_cpup(pos));
  1159. break;
  1160. case 1:
  1161. printk(KERN_DEFAULT " %08x %08x\n",
  1162. be32_to_cpup(pos), be32_to_cpup(pos + 1));
  1163. break;
  1164. case 2:
  1165. printk(KERN_DEFAULT " %08x %08x %08x\n",
  1166. be32_to_cpup(pos), be32_to_cpup(pos + 1),
  1167. be32_to_cpup(pos + 2));
  1168. break;
  1169. default:
  1170. printk(KERN_DEFAULT " %08x %08x %08x %08x\n",
  1171. be32_to_cpup(pos), be32_to_cpup(pos + 1),
  1172. be32_to_cpup(pos + 2), be32_to_cpup(pos + 3));
  1173. }
  1174. }
  1175. }
  1176. EXPORT_SYMBOL_GPL(_nfs_display_fhandle);
  1177. #endif
  1178. /**
  1179. * nfs_inode_attrs_need_update - check if the inode attributes need updating
  1180. * @inode - pointer to inode
  1181. * @fattr - attributes
  1182. *
  1183. * Attempt to divine whether or not an RPC call reply carrying stale
  1184. * attributes got scheduled after another call carrying updated ones.
  1185. *
  1186. * To do so, the function first assumes that a more recent ctime means
  1187. * that the attributes in fattr are newer, however it also attempt to
  1188. * catch the case where ctime either didn't change, or went backwards
  1189. * (if someone reset the clock on the server) by looking at whether
  1190. * or not this RPC call was started after the inode was last updated.
  1191. * Note also the check for wraparound of 'attr_gencount'
  1192. *
  1193. * The function returns 'true' if it thinks the attributes in 'fattr' are
  1194. * more recent than the ones cached in the inode.
  1195. *
  1196. */
  1197. static int nfs_inode_attrs_need_update(const struct inode *inode, const struct nfs_fattr *fattr)
  1198. {
  1199. const struct nfs_inode *nfsi = NFS_I(inode);
  1200. return ((long)fattr->gencount - (long)nfsi->attr_gencount) > 0 ||
  1201. nfs_ctime_need_update(inode, fattr) ||
  1202. nfs_size_need_update(inode, fattr) ||
  1203. ((long)nfsi->attr_gencount - (long)nfs_read_attr_generation_counter() > 0);
  1204. }
  1205. /*
  1206. * Don't trust the change_attribute, mtime, ctime or size if
  1207. * a pnfs LAYOUTCOMMIT is outstanding
  1208. */
  1209. static void nfs_inode_attrs_handle_layoutcommit(struct inode *inode,
  1210. struct nfs_fattr *fattr)
  1211. {
  1212. if (pnfs_layoutcommit_outstanding(inode))
  1213. fattr->valid &= ~(NFS_ATTR_FATTR_CHANGE |
  1214. NFS_ATTR_FATTR_MTIME |
  1215. NFS_ATTR_FATTR_CTIME |
  1216. NFS_ATTR_FATTR_SIZE);
  1217. }
  1218. static int nfs_refresh_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
  1219. {
  1220. int ret;
  1221. trace_nfs_refresh_inode_enter(inode);
  1222. nfs_inode_attrs_handle_layoutcommit(inode, fattr);
  1223. if (nfs_inode_attrs_need_update(inode, fattr))
  1224. ret = nfs_update_inode(inode, fattr);
  1225. else
  1226. ret = nfs_check_inode_attributes(inode, fattr);
  1227. trace_nfs_refresh_inode_exit(inode, ret);
  1228. return ret;
  1229. }
  1230. /**
  1231. * nfs_refresh_inode - try to update the inode attribute cache
  1232. * @inode - pointer to inode
  1233. * @fattr - updated attributes
  1234. *
  1235. * Check that an RPC call that returned attributes has not overlapped with
  1236. * other recent updates of the inode metadata, then decide whether it is
  1237. * safe to do a full update of the inode attributes, or whether just to
  1238. * call nfs_check_inode_attributes.
  1239. */
  1240. int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
  1241. {
  1242. int status;
  1243. if ((fattr->valid & NFS_ATTR_FATTR) == 0)
  1244. return 0;
  1245. spin_lock(&inode->i_lock);
  1246. status = nfs_refresh_inode_locked(inode, fattr);
  1247. spin_unlock(&inode->i_lock);
  1248. return status;
  1249. }
  1250. EXPORT_SYMBOL_GPL(nfs_refresh_inode);
  1251. static int nfs_post_op_update_inode_locked(struct inode *inode, struct nfs_fattr *fattr)
  1252. {
  1253. unsigned long invalid = NFS_INO_INVALID_ATTR|NFS_INO_REVAL_PAGECACHE;
  1254. if (S_ISDIR(inode->i_mode))
  1255. invalid |= NFS_INO_INVALID_DATA;
  1256. nfs_set_cache_invalid(inode, invalid);
  1257. if ((fattr->valid & NFS_ATTR_FATTR) == 0)
  1258. return 0;
  1259. return nfs_refresh_inode_locked(inode, fattr);
  1260. }
  1261. /**
  1262. * nfs_post_op_update_inode - try to update the inode attribute cache
  1263. * @inode - pointer to inode
  1264. * @fattr - updated attributes
  1265. *
  1266. * After an operation that has changed the inode metadata, mark the
  1267. * attribute cache as being invalid, then try to update it.
  1268. *
  1269. * NB: if the server didn't return any post op attributes, this
  1270. * function will force the retrieval of attributes before the next
  1271. * NFS request. Thus it should be used only for operations that
  1272. * are expected to change one or more attributes, to avoid
  1273. * unnecessary NFS requests and trips through nfs_update_inode().
  1274. */
  1275. int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
  1276. {
  1277. int status;
  1278. spin_lock(&inode->i_lock);
  1279. status = nfs_post_op_update_inode_locked(inode, fattr);
  1280. spin_unlock(&inode->i_lock);
  1281. return status;
  1282. }
  1283. EXPORT_SYMBOL_GPL(nfs_post_op_update_inode);
  1284. /**
  1285. * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache
  1286. * @inode - pointer to inode
  1287. * @fattr - updated attributes
  1288. *
  1289. * After an operation that has changed the inode metadata, mark the
  1290. * attribute cache as being invalid, then try to update it. Fake up
  1291. * weak cache consistency data, if none exist.
  1292. *
  1293. * This function is mainly designed to be used by the ->write_done() functions.
  1294. */
  1295. int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr)
  1296. {
  1297. int status;
  1298. spin_lock(&inode->i_lock);
  1299. /* Don't do a WCC update if these attributes are already stale */
  1300. if ((fattr->valid & NFS_ATTR_FATTR) == 0 ||
  1301. !nfs_inode_attrs_need_update(inode, fattr)) {
  1302. fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE
  1303. | NFS_ATTR_FATTR_PRESIZE
  1304. | NFS_ATTR_FATTR_PREMTIME
  1305. | NFS_ATTR_FATTR_PRECTIME);
  1306. goto out_noforce;
  1307. }
  1308. if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
  1309. (fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) {
  1310. fattr->pre_change_attr = inode->i_version;
  1311. fattr->valid |= NFS_ATTR_FATTR_PRECHANGE;
  1312. }
  1313. if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 &&
  1314. (fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) {
  1315. memcpy(&fattr->pre_ctime, &inode->i_ctime, sizeof(fattr->pre_ctime));
  1316. fattr->valid |= NFS_ATTR_FATTR_PRECTIME;
  1317. }
  1318. if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 &&
  1319. (fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) {
  1320. memcpy(&fattr->pre_mtime, &inode->i_mtime, sizeof(fattr->pre_mtime));
  1321. fattr->valid |= NFS_ATTR_FATTR_PREMTIME;
  1322. }
  1323. if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 &&
  1324. (fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) {
  1325. fattr->pre_size = i_size_read(inode);
  1326. fattr->valid |= NFS_ATTR_FATTR_PRESIZE;
  1327. }
  1328. out_noforce:
  1329. status = nfs_post_op_update_inode_locked(inode, fattr);
  1330. spin_unlock(&inode->i_lock);
  1331. return status;
  1332. }
  1333. EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc);
  1334. /*
  1335. * Many nfs protocol calls return the new file attributes after
  1336. * an operation. Here we update the inode to reflect the state
  1337. * of the server's inode.
  1338. *
  1339. * This is a bit tricky because we have to make sure all dirty pages
  1340. * have been sent off to the server before calling invalidate_inode_pages.
  1341. * To make sure no other process adds more write requests while we try
  1342. * our best to flush them, we make them sleep during the attribute refresh.
  1343. *
  1344. * A very similar scenario holds for the dir cache.
  1345. */
  1346. static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
  1347. {
  1348. struct nfs_server *server;
  1349. struct nfs_inode *nfsi = NFS_I(inode);
  1350. loff_t cur_isize, new_isize;
  1351. unsigned long invalid = 0;
  1352. unsigned long now = jiffies;
  1353. unsigned long save_cache_validity;
  1354. dfprintk(VFS, "NFS: %s(%s/%lu fh_crc=0x%08x ct=%d info=0x%x)\n",
  1355. __func__, inode->i_sb->s_id, inode->i_ino,
  1356. nfs_display_fhandle_hash(NFS_FH(inode)),
  1357. atomic_read(&inode->i_count), fattr->valid);
  1358. if ((fattr->valid & NFS_ATTR_FATTR_FILEID) && nfsi->fileid != fattr->fileid) {
  1359. printk(KERN_ERR "NFS: server %s error: fileid changed\n"
  1360. "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
  1361. NFS_SERVER(inode)->nfs_client->cl_hostname,
  1362. inode->i_sb->s_id, (long long)nfsi->fileid,
  1363. (long long)fattr->fileid);
  1364. goto out_err;
  1365. }
  1366. /*
  1367. * Make sure the inode's type hasn't changed.
  1368. */
  1369. if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && (inode->i_mode & S_IFMT) != (fattr->mode & S_IFMT)) {
  1370. /*
  1371. * Big trouble! The inode has become a different object.
  1372. */
  1373. printk(KERN_DEBUG "NFS: %s: inode %lu mode changed, %07o to %07o\n",
  1374. __func__, inode->i_ino, inode->i_mode, fattr->mode);
  1375. goto out_err;
  1376. }
  1377. server = NFS_SERVER(inode);
  1378. /* Update the fsid? */
  1379. if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) &&
  1380. !nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
  1381. !IS_AUTOMOUNT(inode))
  1382. server->fsid = fattr->fsid;
  1383. /*
  1384. * Update the read time so we don't revalidate too often.
  1385. */
  1386. nfsi->read_cache_jiffies = fattr->time_start;
  1387. save_cache_validity = nfsi->cache_validity;
  1388. nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR
  1389. | NFS_INO_INVALID_ATIME
  1390. | NFS_INO_REVAL_FORCED
  1391. | NFS_INO_REVAL_PAGECACHE);
  1392. /* Do atomic weak cache consistency updates */
  1393. invalid |= nfs_wcc_update_inode(inode, fattr);
  1394. /* More cache consistency checks */
  1395. if (fattr->valid & NFS_ATTR_FATTR_CHANGE) {
  1396. if (inode->i_version != fattr->change_attr) {
  1397. dprintk("NFS: change_attr change on server for file %s/%ld\n",
  1398. inode->i_sb->s_id, inode->i_ino);
  1399. invalid |= NFS_INO_INVALID_ATTR
  1400. | NFS_INO_INVALID_DATA
  1401. | NFS_INO_INVALID_ACCESS
  1402. | NFS_INO_INVALID_ACL
  1403. | NFS_INO_REVAL_PAGECACHE;
  1404. if (S_ISDIR(inode->i_mode))
  1405. nfs_force_lookup_revalidate(inode);
  1406. inode->i_version = fattr->change_attr;
  1407. }
  1408. } else if (server->caps & NFS_CAP_CHANGE_ATTR)
  1409. nfsi->cache_validity |= save_cache_validity;
  1410. if (fattr->valid & NFS_ATTR_FATTR_MTIME) {
  1411. memcpy(&inode->i_mtime, &fattr->mtime, sizeof(inode->i_mtime));
  1412. } else if (server->caps & NFS_CAP_MTIME)
  1413. nfsi->cache_validity |= save_cache_validity &
  1414. (NFS_INO_INVALID_ATTR
  1415. | NFS_INO_REVAL_FORCED);
  1416. if (fattr->valid & NFS_ATTR_FATTR_CTIME) {
  1417. memcpy(&inode->i_ctime, &fattr->ctime, sizeof(inode->i_ctime));
  1418. } else if (server->caps & NFS_CAP_CTIME)
  1419. nfsi->cache_validity |= save_cache_validity &
  1420. (NFS_INO_INVALID_ATTR
  1421. | NFS_INO_REVAL_FORCED);
  1422. /* Check if our cached file size is stale */
  1423. if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
  1424. new_isize = nfs_size_to_loff_t(fattr->size);
  1425. cur_isize = i_size_read(inode);
  1426. if (new_isize != cur_isize) {
  1427. /* Do we perhaps have any outstanding writes, or has
  1428. * the file grown beyond our last write? */
  1429. if ((nfsi->nrequests == 0) || new_isize > cur_isize) {
  1430. i_size_write(inode, new_isize);
  1431. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
  1432. invalid &= ~NFS_INO_REVAL_PAGECACHE;
  1433. }
  1434. dprintk("NFS: isize change on server for file %s/%ld "
  1435. "(%Ld to %Ld)\n",
  1436. inode->i_sb->s_id,
  1437. inode->i_ino,
  1438. (long long)cur_isize,
  1439. (long long)new_isize);
  1440. }
  1441. } else
  1442. nfsi->cache_validity |= save_cache_validity &
  1443. (NFS_INO_INVALID_ATTR
  1444. | NFS_INO_REVAL_PAGECACHE
  1445. | NFS_INO_REVAL_FORCED);
  1446. if (fattr->valid & NFS_ATTR_FATTR_ATIME)
  1447. memcpy(&inode->i_atime, &fattr->atime, sizeof(inode->i_atime));
  1448. else if (server->caps & NFS_CAP_ATIME)
  1449. nfsi->cache_validity |= save_cache_validity &
  1450. (NFS_INO_INVALID_ATIME
  1451. | NFS_INO_REVAL_FORCED);
  1452. if (fattr->valid & NFS_ATTR_FATTR_MODE) {
  1453. if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
  1454. umode_t newmode = inode->i_mode & S_IFMT;
  1455. newmode |= fattr->mode & S_IALLUGO;
  1456. inode->i_mode = newmode;
  1457. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
  1458. }
  1459. } else if (server->caps & NFS_CAP_MODE)
  1460. nfsi->cache_validity |= save_cache_validity &
  1461. (NFS_INO_INVALID_ATTR
  1462. | NFS_INO_INVALID_ACCESS
  1463. | NFS_INO_INVALID_ACL
  1464. | NFS_INO_REVAL_FORCED);
  1465. if (fattr->valid & NFS_ATTR_FATTR_OWNER) {
  1466. if (!uid_eq(inode->i_uid, fattr->uid)) {
  1467. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
  1468. inode->i_uid = fattr->uid;
  1469. }
  1470. } else if (server->caps & NFS_CAP_OWNER)
  1471. nfsi->cache_validity |= save_cache_validity &
  1472. (NFS_INO_INVALID_ATTR
  1473. | NFS_INO_INVALID_ACCESS
  1474. | NFS_INO_INVALID_ACL
  1475. | NFS_INO_REVAL_FORCED);
  1476. if (fattr->valid & NFS_ATTR_FATTR_GROUP) {
  1477. if (!gid_eq(inode->i_gid, fattr->gid)) {
  1478. invalid |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ACCESS|NFS_INO_INVALID_ACL;
  1479. inode->i_gid = fattr->gid;
  1480. }
  1481. } else if (server->caps & NFS_CAP_OWNER_GROUP)
  1482. nfsi->cache_validity |= save_cache_validity &
  1483. (NFS_INO_INVALID_ATTR
  1484. | NFS_INO_INVALID_ACCESS
  1485. | NFS_INO_INVALID_ACL
  1486. | NFS_INO_REVAL_FORCED);
  1487. if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
  1488. if (inode->i_nlink != fattr->nlink) {
  1489. invalid |= NFS_INO_INVALID_ATTR;
  1490. if (S_ISDIR(inode->i_mode))
  1491. invalid |= NFS_INO_INVALID_DATA;
  1492. set_nlink(inode, fattr->nlink);
  1493. }
  1494. } else if (server->caps & NFS_CAP_NLINK)
  1495. nfsi->cache_validity |= save_cache_validity &
  1496. (NFS_INO_INVALID_ATTR
  1497. | NFS_INO_REVAL_FORCED);
  1498. if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
  1499. /*
  1500. * report the blocks in 512byte units
  1501. */
  1502. inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
  1503. }
  1504. if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
  1505. inode->i_blocks = fattr->du.nfs2.blocks;
  1506. /* Update attrtimeo value if we're out of the unstable period */
  1507. if (invalid & NFS_INO_INVALID_ATTR) {
  1508. nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
  1509. nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
  1510. nfsi->attrtimeo_timestamp = now;
  1511. nfsi->attr_gencount = nfs_inc_attr_generation_counter();
  1512. } else {
  1513. if (!time_in_range_open(now, nfsi->attrtimeo_timestamp, nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
  1514. if ((nfsi->attrtimeo <<= 1) > NFS_MAXATTRTIMEO(inode))
  1515. nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
  1516. nfsi->attrtimeo_timestamp = now;
  1517. }
  1518. }
  1519. invalid &= ~NFS_INO_INVALID_ATTR;
  1520. /* Don't invalidate the data if we were to blame */
  1521. if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
  1522. || S_ISLNK(inode->i_mode)))
  1523. invalid &= ~NFS_INO_INVALID_DATA;
  1524. if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ) ||
  1525. (save_cache_validity & NFS_INO_REVAL_FORCED))
  1526. nfs_set_cache_invalid(inode, invalid);
  1527. return 0;
  1528. out_err:
  1529. /*
  1530. * No need to worry about unhashing the dentry, as the
  1531. * lookup validation will know that the inode is bad.
  1532. * (But we fall through to invalidate the caches.)
  1533. */
  1534. nfs_invalidate_inode(inode);
  1535. return -ESTALE;
  1536. }
  1537. struct inode *nfs_alloc_inode(struct super_block *sb)
  1538. {
  1539. struct nfs_inode *nfsi;
  1540. nfsi = (struct nfs_inode *)kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
  1541. if (!nfsi)
  1542. return NULL;
  1543. nfsi->flags = 0UL;
  1544. nfsi->cache_validity = 0UL;
  1545. #if IS_ENABLED(CONFIG_NFS_V4)
  1546. nfsi->nfs4_acl = NULL;
  1547. #endif /* CONFIG_NFS_V4 */
  1548. return &nfsi->vfs_inode;
  1549. }
  1550. EXPORT_SYMBOL_GPL(nfs_alloc_inode);
  1551. static void nfs_i_callback(struct rcu_head *head)
  1552. {
  1553. struct inode *inode = container_of(head, struct inode, i_rcu);
  1554. kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
  1555. }
  1556. void nfs_destroy_inode(struct inode *inode)
  1557. {
  1558. call_rcu(&inode->i_rcu, nfs_i_callback);
  1559. }
  1560. EXPORT_SYMBOL_GPL(nfs_destroy_inode);
  1561. static inline void nfs4_init_once(struct nfs_inode *nfsi)
  1562. {
  1563. #if IS_ENABLED(CONFIG_NFS_V4)
  1564. INIT_LIST_HEAD(&nfsi->open_states);
  1565. nfsi->delegation = NULL;
  1566. init_rwsem(&nfsi->rwsem);
  1567. nfsi->layout = NULL;
  1568. #endif
  1569. }
  1570. static void init_once(void *foo)
  1571. {
  1572. struct nfs_inode *nfsi = (struct nfs_inode *) foo;
  1573. inode_init_once(&nfsi->vfs_inode);
  1574. INIT_LIST_HEAD(&nfsi->open_files);
  1575. INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
  1576. INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
  1577. INIT_LIST_HEAD(&nfsi->commit_info.list);
  1578. nfsi->nrequests = 0;
  1579. nfsi->commit_info.ncommit = 0;
  1580. atomic_set(&nfsi->commit_info.rpcs_out, 0);
  1581. atomic_set(&nfsi->silly_count, 1);
  1582. INIT_HLIST_HEAD(&nfsi->silly_list);
  1583. init_waitqueue_head(&nfsi->waitqueue);
  1584. nfs4_init_once(nfsi);
  1585. }
  1586. static int __init nfs_init_inodecache(void)
  1587. {
  1588. nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
  1589. sizeof(struct nfs_inode),
  1590. 0, (SLAB_RECLAIM_ACCOUNT|
  1591. SLAB_MEM_SPREAD),
  1592. init_once);
  1593. if (nfs_inode_cachep == NULL)
  1594. return -ENOMEM;
  1595. return 0;
  1596. }
  1597. static void nfs_destroy_inodecache(void)
  1598. {
  1599. /*
  1600. * Make sure all delayed rcu free inodes are flushed before we
  1601. * destroy cache.
  1602. */
  1603. rcu_barrier();
  1604. kmem_cache_destroy(nfs_inode_cachep);
  1605. }
  1606. struct workqueue_struct *nfsiod_workqueue;
  1607. EXPORT_SYMBOL_GPL(nfsiod_workqueue);
  1608. /*
  1609. * start up the nfsiod workqueue
  1610. */
  1611. static int nfsiod_start(void)
  1612. {
  1613. struct workqueue_struct *wq;
  1614. dprintk("RPC: creating workqueue nfsiod\n");
  1615. wq = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM, 0);
  1616. if (wq == NULL)
  1617. return -ENOMEM;
  1618. nfsiod_workqueue = wq;
  1619. return 0;
  1620. }
  1621. /*
  1622. * Destroy the nfsiod workqueue
  1623. */
  1624. static void nfsiod_stop(void)
  1625. {
  1626. struct workqueue_struct *wq;
  1627. wq = nfsiod_workqueue;
  1628. if (wq == NULL)
  1629. return;
  1630. nfsiod_workqueue = NULL;
  1631. destroy_workqueue(wq);
  1632. }
  1633. int nfs_net_id;
  1634. EXPORT_SYMBOL_GPL(nfs_net_id);
  1635. static int nfs_net_init(struct net *net)
  1636. {
  1637. nfs_clients_init(net);
  1638. return nfs_fs_proc_net_init(net);
  1639. }
  1640. static void nfs_net_exit(struct net *net)
  1641. {
  1642. nfs_fs_proc_net_exit(net);
  1643. nfs_cleanup_cb_ident_idr(net);
  1644. }
  1645. static struct pernet_operations nfs_net_ops = {
  1646. .init = nfs_net_init,
  1647. .exit = nfs_net_exit,
  1648. .id = &nfs_net_id,
  1649. .size = sizeof(struct nfs_net),
  1650. };
  1651. /*
  1652. * Initialize NFS
  1653. */
  1654. static int __init init_nfs_fs(void)
  1655. {
  1656. int err;
  1657. err = register_pernet_subsys(&nfs_net_ops);
  1658. if (err < 0)
  1659. goto out9;
  1660. err = nfs_fscache_register();
  1661. if (err < 0)
  1662. goto out8;
  1663. err = nfsiod_start();
  1664. if (err)
  1665. goto out7;
  1666. err = nfs_fs_proc_init();
  1667. if (err)
  1668. goto out6;
  1669. err = nfs_init_nfspagecache();
  1670. if (err)
  1671. goto out5;
  1672. err = nfs_init_inodecache();
  1673. if (err)
  1674. goto out4;
  1675. err = nfs_init_readpagecache();
  1676. if (err)
  1677. goto out3;
  1678. err = nfs_init_writepagecache();
  1679. if (err)
  1680. goto out2;
  1681. err = nfs_init_directcache();
  1682. if (err)
  1683. goto out1;
  1684. #ifdef CONFIG_PROC_FS
  1685. rpc_proc_register(&init_net, &nfs_rpcstat);
  1686. #endif
  1687. if ((err = register_nfs_fs()) != 0)
  1688. goto out0;
  1689. return 0;
  1690. out0:
  1691. #ifdef CONFIG_PROC_FS
  1692. rpc_proc_unregister(&init_net, "nfs");
  1693. #endif
  1694. nfs_destroy_directcache();
  1695. out1:
  1696. nfs_destroy_writepagecache();
  1697. out2:
  1698. nfs_destroy_readpagecache();
  1699. out3:
  1700. nfs_destroy_inodecache();
  1701. out4:
  1702. nfs_destroy_nfspagecache();
  1703. out5:
  1704. nfs_fs_proc_exit();
  1705. out6:
  1706. nfsiod_stop();
  1707. out7:
  1708. nfs_fscache_unregister();
  1709. out8:
  1710. unregister_pernet_subsys(&nfs_net_ops);
  1711. out9:
  1712. return err;
  1713. }
  1714. static void __exit exit_nfs_fs(void)
  1715. {
  1716. nfs_destroy_directcache();
  1717. nfs_destroy_writepagecache();
  1718. nfs_destroy_readpagecache();
  1719. nfs_destroy_inodecache();
  1720. nfs_destroy_nfspagecache();
  1721. nfs_fscache_unregister();
  1722. unregister_pernet_subsys(&nfs_net_ops);
  1723. #ifdef CONFIG_PROC_FS
  1724. rpc_proc_unregister(&init_net, "nfs");
  1725. #endif
  1726. unregister_nfs_fs();
  1727. nfs_fs_proc_exit();
  1728. nfsiod_stop();
  1729. }
  1730. /* Not quite true; I just maintain it */
  1731. MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
  1732. MODULE_LICENSE("GPL");
  1733. module_param(enable_ino64, bool, 0644);
  1734. module_init(init_nfs_fs)
  1735. module_exit(exit_nfs_fs)