inode.c 45 KB

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