1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * linux/fs/nfs/inode.c
4 *
5 * Copyright (C) 1992 Rick Sladkey
6 *
7 * nfs inode and superblock handling functions
8 *
9 * Modularised by Alan Cox <alan@lxorguk.ukuu.org.uk>, while hacking some
10 * experimental NFS changes. Modularisation taken straight from SYS5 fs.
11 *
12 * Change to nfs_read_super() to permit NFS mounts to multi-homed hosts.
13 * J.S.Peatfield@damtp.cam.ac.uk
14 *
15 */
16
17 #include <linux/module.h>
18 #include <linux/init.h>
19 #include <linux/sched/signal.h>
20 #include <linux/time.h>
21 #include <linux/kernel.h>
22 #include <linux/mm.h>
23 #include <linux/string.h>
24 #include <linux/stat.h>
25 #include <linux/errno.h>
26 #include <linux/unistd.h>
27 #include <linux/sunrpc/clnt.h>
28 #include <linux/sunrpc/stats.h>
29 #include <linux/sunrpc/metrics.h>
30 #include <linux/nfs_fs.h>
31 #include <linux/nfs_mount.h>
32 #include <linux/nfs4_mount.h>
33 #include <linux/lockd/bind.h>
34 #include <linux/seq_file.h>
35 #include <linux/mount.h>
36 #include <linux/vfs.h>
37 #include <linux/inet.h>
38 #include <linux/nfs_xdr.h>
39 #include <linux/slab.h>
40 #include <linux/compat.h>
41 #include <linux/freezer.h>
42 #include <linux/uaccess.h>
43 #include <linux/iversion.h>
44
45 #include "nfs4_fs.h"
46 #include "callback.h"
47 #include "delegation.h"
48 #include "iostat.h"
49 #include "internal.h"
50 #include "fscache.h"
51 #include "pnfs.h"
52 #include "nfs.h"
53 #include "netns.h"
54 #include "sysfs.h"
55
56 #include "nfstrace.h"
57
58 #define NFSDBG_FACILITY NFSDBG_VFS
59
60 #define NFS_64_BIT_INODE_NUMBERS_ENABLED 1
61
62 /* Default is to see 64-bit inode numbers */
63 static bool enable_ino64 = NFS_64_BIT_INODE_NUMBERS_ENABLED;
64
65 static int nfs_update_inode(struct inode *, struct nfs_fattr *);
66
67 static struct kmem_cache * nfs_inode_cachep;
68
69 static inline unsigned long
nfs_fattr_to_ino_t(struct nfs_fattr * fattr)70 nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
71 {
72 return nfs_fileid_to_ino_t(fattr->fileid);
73 }
74
nfs_wait_killable(int mode)75 static int nfs_wait_killable(int mode)
76 {
77 freezable_schedule_unsafe();
78 if (signal_pending_state(mode, current))
79 return -ERESTARTSYS;
80 return 0;
81 }
82
nfs_wait_bit_killable(struct wait_bit_key * key,int mode)83 int nfs_wait_bit_killable(struct wait_bit_key *key, int mode)
84 {
85 return nfs_wait_killable(mode);
86 }
87 EXPORT_SYMBOL_GPL(nfs_wait_bit_killable);
88
89 /**
90 * nfs_compat_user_ino64 - returns the user-visible inode number
91 * @fileid: 64-bit fileid
92 *
93 * This function returns a 32-bit inode number if the boot parameter
94 * nfs.enable_ino64 is zero.
95 */
nfs_compat_user_ino64(u64 fileid)96 u64 nfs_compat_user_ino64(u64 fileid)
97 {
98 #ifdef CONFIG_COMPAT
99 compat_ulong_t ino;
100 #else
101 unsigned long ino;
102 #endif
103
104 if (enable_ino64)
105 return fileid;
106 ino = fileid;
107 if (sizeof(ino) < sizeof(fileid))
108 ino ^= fileid >> (sizeof(fileid)-sizeof(ino)) * 8;
109 return ino;
110 }
111
nfs_drop_inode(struct inode * inode)112 int nfs_drop_inode(struct inode *inode)
113 {
114 return NFS_STALE(inode) || generic_drop_inode(inode);
115 }
116 EXPORT_SYMBOL_GPL(nfs_drop_inode);
117
nfs_clear_inode(struct inode * inode)118 void nfs_clear_inode(struct inode *inode)
119 {
120 /*
121 * The following should never happen...
122 */
123 WARN_ON_ONCE(nfs_have_writebacks(inode));
124 WARN_ON_ONCE(!list_empty(&NFS_I(inode)->open_files));
125 nfs_zap_acl_cache(inode);
126 nfs_access_zap_cache(inode);
127 nfs_fscache_clear_inode(inode);
128 }
129 EXPORT_SYMBOL_GPL(nfs_clear_inode);
130
nfs_evict_inode(struct inode * inode)131 void nfs_evict_inode(struct inode *inode)
132 {
133 truncate_inode_pages_final(&inode->i_data);
134 clear_inode(inode);
135 nfs_clear_inode(inode);
136 }
137
nfs_sync_inode(struct inode * inode)138 int nfs_sync_inode(struct inode *inode)
139 {
140 inode_dio_wait(inode);
141 return nfs_wb_all(inode);
142 }
143 EXPORT_SYMBOL_GPL(nfs_sync_inode);
144
145 /**
146 * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
147 * @mapping: pointer to struct address_space
148 */
nfs_sync_mapping(struct address_space * mapping)149 int nfs_sync_mapping(struct address_space *mapping)
150 {
151 int ret = 0;
152
153 if (mapping->nrpages != 0) {
154 unmap_mapping_range(mapping, 0, 0, 0);
155 ret = nfs_wb_all(mapping->host);
156 }
157 return ret;
158 }
159
nfs_attribute_timeout(struct inode * inode)160 static int nfs_attribute_timeout(struct inode *inode)
161 {
162 struct nfs_inode *nfsi = NFS_I(inode);
163
164 return !time_in_range_open(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo);
165 }
166
nfs_check_cache_flags_invalid(struct inode * inode,unsigned long flags)167 static bool nfs_check_cache_flags_invalid(struct inode *inode,
168 unsigned long flags)
169 {
170 unsigned long cache_validity = READ_ONCE(NFS_I(inode)->cache_validity);
171
172 return (cache_validity & flags) != 0;
173 }
174
nfs_check_cache_invalid(struct inode * inode,unsigned long flags)175 bool nfs_check_cache_invalid(struct inode *inode, unsigned long flags)
176 {
177 if (nfs_check_cache_flags_invalid(inode, flags))
178 return true;
179 return nfs_attribute_cache_expired(inode);
180 }
181 EXPORT_SYMBOL_GPL(nfs_check_cache_invalid);
182
183 #ifdef CONFIG_NFS_V4_2
nfs_has_xattr_cache(const struct nfs_inode * nfsi)184 static bool nfs_has_xattr_cache(const struct nfs_inode *nfsi)
185 {
186 return nfsi->xattr_cache != NULL;
187 }
188 #else
nfs_has_xattr_cache(const struct nfs_inode * nfsi)189 static bool nfs_has_xattr_cache(const struct nfs_inode *nfsi)
190 {
191 return false;
192 }
193 #endif
194
nfs_set_cache_invalid(struct inode * inode,unsigned long flags)195 void nfs_set_cache_invalid(struct inode *inode, unsigned long flags)
196 {
197 struct nfs_inode *nfsi = NFS_I(inode);
198 bool have_delegation = NFS_PROTO(inode)->have_delegation(inode, FMODE_READ);
199
200 if (have_delegation) {
201 if (!(flags & NFS_INO_REVAL_FORCED))
202 flags &= ~(NFS_INO_INVALID_MODE |
203 NFS_INO_INVALID_OTHER |
204 NFS_INO_INVALID_XATTR);
205 flags &= ~(NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_SIZE);
206 } else if (flags & NFS_INO_REVAL_PAGECACHE)
207 flags |= NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_SIZE;
208
209 if (!nfs_has_xattr_cache(nfsi))
210 flags &= ~NFS_INO_INVALID_XATTR;
211 if (flags & NFS_INO_INVALID_DATA)
212 nfs_fscache_invalidate(inode);
213 flags &= ~(NFS_INO_REVAL_PAGECACHE | NFS_INO_REVAL_FORCED);
214
215 nfsi->cache_validity |= flags;
216
217 if (inode->i_mapping->nrpages == 0)
218 nfsi->cache_validity &= ~(NFS_INO_INVALID_DATA |
219 NFS_INO_DATA_INVAL_DEFER);
220 else if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
221 nfsi->cache_validity &= ~NFS_INO_DATA_INVAL_DEFER;
222 trace_nfs_set_cache_invalid(inode, 0);
223 }
224 EXPORT_SYMBOL_GPL(nfs_set_cache_invalid);
225
226 /*
227 * Invalidate the local caches
228 */
nfs_zap_caches_locked(struct inode * inode)229 static void nfs_zap_caches_locked(struct inode *inode)
230 {
231 struct nfs_inode *nfsi = NFS_I(inode);
232 int mode = inode->i_mode;
233
234 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
235
236 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
237 nfsi->attrtimeo_timestamp = jiffies;
238
239 if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) {
240 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR
241 | NFS_INO_INVALID_DATA
242 | NFS_INO_INVALID_ACCESS
243 | NFS_INO_INVALID_ACL
244 | NFS_INO_INVALID_XATTR
245 | NFS_INO_REVAL_PAGECACHE);
246 } else
247 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR
248 | NFS_INO_INVALID_ACCESS
249 | NFS_INO_INVALID_ACL
250 | NFS_INO_INVALID_XATTR
251 | NFS_INO_REVAL_PAGECACHE);
252 nfs_zap_label_cache_locked(nfsi);
253 }
254
nfs_zap_caches(struct inode * inode)255 void nfs_zap_caches(struct inode *inode)
256 {
257 spin_lock(&inode->i_lock);
258 nfs_zap_caches_locked(inode);
259 spin_unlock(&inode->i_lock);
260 }
261
nfs_zap_mapping(struct inode * inode,struct address_space * mapping)262 void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
263 {
264 if (mapping->nrpages != 0) {
265 spin_lock(&inode->i_lock);
266 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
267 spin_unlock(&inode->i_lock);
268 }
269 }
270
nfs_zap_acl_cache(struct inode * inode)271 void nfs_zap_acl_cache(struct inode *inode)
272 {
273 void (*clear_acl_cache)(struct inode *);
274
275 clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
276 if (clear_acl_cache != NULL)
277 clear_acl_cache(inode);
278 spin_lock(&inode->i_lock);
279 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
280 spin_unlock(&inode->i_lock);
281 }
282 EXPORT_SYMBOL_GPL(nfs_zap_acl_cache);
283
nfs_invalidate_atime(struct inode * inode)284 void nfs_invalidate_atime(struct inode *inode)
285 {
286 spin_lock(&inode->i_lock);
287 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
288 spin_unlock(&inode->i_lock);
289 }
290 EXPORT_SYMBOL_GPL(nfs_invalidate_atime);
291
292 /*
293 * Invalidate, but do not unhash, the inode.
294 * NB: must be called with inode->i_lock held!
295 */
nfs_set_inode_stale_locked(struct inode * inode)296 static void nfs_set_inode_stale_locked(struct inode *inode)
297 {
298 set_bit(NFS_INO_STALE, &NFS_I(inode)->flags);
299 nfs_zap_caches_locked(inode);
300 trace_nfs_set_inode_stale(inode);
301 }
302
nfs_set_inode_stale(struct inode * inode)303 void nfs_set_inode_stale(struct inode *inode)
304 {
305 spin_lock(&inode->i_lock);
306 nfs_set_inode_stale_locked(inode);
307 spin_unlock(&inode->i_lock);
308 }
309
310 struct nfs_find_desc {
311 struct nfs_fh *fh;
312 struct nfs_fattr *fattr;
313 };
314
315 /*
316 * In NFSv3 we can have 64bit inode numbers. In order to support
317 * this, and re-exported directories (also seen in NFSv2)
318 * we are forced to allow 2 different inodes to have the same
319 * i_ino.
320 */
321 static int
nfs_find_actor(struct inode * inode,void * opaque)322 nfs_find_actor(struct inode *inode, void *opaque)
323 {
324 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
325 struct nfs_fh *fh = desc->fh;
326 struct nfs_fattr *fattr = desc->fattr;
327
328 if (NFS_FILEID(inode) != fattr->fileid)
329 return 0;
330 if (inode_wrong_type(inode, fattr->mode))
331 return 0;
332 if (nfs_compare_fh(NFS_FH(inode), fh))
333 return 0;
334 if (is_bad_inode(inode) || NFS_STALE(inode))
335 return 0;
336 return 1;
337 }
338
339 static int
nfs_init_locked(struct inode * inode,void * opaque)340 nfs_init_locked(struct inode *inode, void *opaque)
341 {
342 struct nfs_find_desc *desc = (struct nfs_find_desc *)opaque;
343 struct nfs_fattr *fattr = desc->fattr;
344
345 set_nfs_fileid(inode, fattr->fileid);
346 inode->i_mode = fattr->mode;
347 nfs_copy_fh(NFS_FH(inode), desc->fh);
348 return 0;
349 }
350
351 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
nfs_clear_label_invalid(struct inode * inode)352 static void nfs_clear_label_invalid(struct inode *inode)
353 {
354 spin_lock(&inode->i_lock);
355 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_LABEL;
356 spin_unlock(&inode->i_lock);
357 }
358
nfs_setsecurity(struct inode * inode,struct nfs_fattr * fattr)359 void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr)
360 {
361 int error;
362
363 if (fattr->label == NULL)
364 return;
365
366 if ((fattr->valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL) && inode->i_security) {
367 error = security_inode_notifysecctx(inode, fattr->label->label,
368 fattr->label->len);
369 if (error)
370 printk(KERN_ERR "%s() %s %d "
371 "security_inode_notifysecctx() %d\n",
372 __func__,
373 (char *)fattr->label->label,
374 fattr->label->len, error);
375 nfs_clear_label_invalid(inode);
376 }
377 }
378
nfs4_label_alloc(struct nfs_server * server,gfp_t flags)379 struct nfs4_label *nfs4_label_alloc(struct nfs_server *server, gfp_t flags)
380 {
381 struct nfs4_label *label;
382
383 if (!(server->caps & NFS_CAP_SECURITY_LABEL))
384 return NULL;
385
386 label = kzalloc(sizeof(struct nfs4_label), flags);
387 if (label == NULL)
388 return ERR_PTR(-ENOMEM);
389
390 label->label = kzalloc(NFS4_MAXLABELLEN, flags);
391 if (label->label == NULL) {
392 kfree(label);
393 return ERR_PTR(-ENOMEM);
394 }
395 label->len = NFS4_MAXLABELLEN;
396
397 return label;
398 }
399 EXPORT_SYMBOL_GPL(nfs4_label_alloc);
400 #else
nfs_setsecurity(struct inode * inode,struct nfs_fattr * fattr)401 void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr)
402 {
403 }
404 #endif
405 EXPORT_SYMBOL_GPL(nfs_setsecurity);
406
407 /* Search for inode identified by fh, fileid and i_mode in inode cache. */
408 struct inode *
nfs_ilookup(struct super_block * sb,struct nfs_fattr * fattr,struct nfs_fh * fh)409 nfs_ilookup(struct super_block *sb, struct nfs_fattr *fattr, struct nfs_fh *fh)
410 {
411 struct nfs_find_desc desc = {
412 .fh = fh,
413 .fattr = fattr,
414 };
415 struct inode *inode;
416 unsigned long hash;
417
418 if (!(fattr->valid & NFS_ATTR_FATTR_FILEID) ||
419 !(fattr->valid & NFS_ATTR_FATTR_TYPE))
420 return NULL;
421
422 hash = nfs_fattr_to_ino_t(fattr);
423 inode = ilookup5(sb, hash, nfs_find_actor, &desc);
424
425 dprintk("%s: returning %p\n", __func__, inode);
426 return inode;
427 }
428
nfs_inode_init_regular(struct nfs_inode * nfsi)429 static void nfs_inode_init_regular(struct nfs_inode *nfsi)
430 {
431 atomic_long_set(&nfsi->nrequests, 0);
432 INIT_LIST_HEAD(&nfsi->commit_info.list);
433 atomic_long_set(&nfsi->commit_info.ncommit, 0);
434 atomic_set(&nfsi->commit_info.rpcs_out, 0);
435 mutex_init(&nfsi->commit_mutex);
436 }
437
nfs_inode_init_dir(struct nfs_inode * nfsi)438 static void nfs_inode_init_dir(struct nfs_inode *nfsi)
439 {
440 nfsi->cache_change_attribute = 0;
441 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
442 init_rwsem(&nfsi->rmdir_sem);
443 }
444
445 /*
446 * This is our front-end to iget that looks up inodes by file handle
447 * instead of inode number.
448 */
449 struct inode *
nfs_fhget(struct super_block * sb,struct nfs_fh * fh,struct nfs_fattr * fattr)450 nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
451 {
452 struct nfs_find_desc desc = {
453 .fh = fh,
454 .fattr = fattr
455 };
456 struct inode *inode = ERR_PTR(-ENOENT);
457 u64 fattr_supported = NFS_SB(sb)->fattr_valid;
458 unsigned long hash;
459
460 nfs_attr_check_mountpoint(sb, fattr);
461
462 if (nfs_attr_use_mounted_on_fileid(fattr))
463 fattr->fileid = fattr->mounted_on_fileid;
464 else if ((fattr->valid & NFS_ATTR_FATTR_FILEID) == 0)
465 goto out_no_inode;
466 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) == 0)
467 goto out_no_inode;
468
469 hash = nfs_fattr_to_ino_t(fattr);
470
471 inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
472 if (inode == NULL) {
473 inode = ERR_PTR(-ENOMEM);
474 goto out_no_inode;
475 }
476
477 if (inode->i_state & I_NEW) {
478 struct nfs_inode *nfsi = NFS_I(inode);
479 unsigned long now = jiffies;
480
481 /* We set i_ino for the few things that still rely on it,
482 * such as stat(2) */
483 inode->i_ino = hash;
484
485 /* We can't support update_atime(), since the server will reset it */
486 inode->i_flags |= S_NOATIME|S_NOCMTIME;
487 inode->i_mode = fattr->mode;
488 nfsi->cache_validity = 0;
489 if ((fattr->valid & NFS_ATTR_FATTR_MODE) == 0
490 && (fattr_supported & NFS_ATTR_FATTR_MODE))
491 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MODE);
492 /* Why so? Because we want revalidate for devices/FIFOs, and
493 * that's precisely what we have in nfs_file_inode_operations.
494 */
495 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
496 if (S_ISREG(inode->i_mode)) {
497 inode->i_fop = NFS_SB(sb)->nfs_client->rpc_ops->file_ops;
498 inode->i_data.a_ops = &nfs_file_aops;
499 nfs_inode_init_regular(nfsi);
500 } else if (S_ISDIR(inode->i_mode)) {
501 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
502 inode->i_fop = &nfs_dir_operations;
503 inode->i_data.a_ops = &nfs_dir_aops;
504 nfs_inode_init_dir(nfsi);
505 /* Deal with crossing mountpoints */
506 if (fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT ||
507 fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
508 if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
509 inode->i_op = &nfs_referral_inode_operations;
510 else
511 inode->i_op = &nfs_mountpoint_inode_operations;
512 inode->i_fop = NULL;
513 inode->i_flags |= S_AUTOMOUNT;
514 }
515 } else if (S_ISLNK(inode->i_mode)) {
516 inode->i_op = &nfs_symlink_inode_operations;
517 inode_nohighmem(inode);
518 } else
519 init_special_inode(inode, inode->i_mode, fattr->rdev);
520
521 memset(&inode->i_atime, 0, sizeof(inode->i_atime));
522 memset(&inode->i_mtime, 0, sizeof(inode->i_mtime));
523 memset(&inode->i_ctime, 0, sizeof(inode->i_ctime));
524 inode_set_iversion_raw(inode, 0);
525 inode->i_size = 0;
526 clear_nlink(inode);
527 inode->i_uid = make_kuid(&init_user_ns, -2);
528 inode->i_gid = make_kgid(&init_user_ns, -2);
529 inode->i_blocks = 0;
530 nfsi->write_io = 0;
531 nfsi->read_io = 0;
532
533 nfsi->read_cache_jiffies = fattr->time_start;
534 nfsi->attr_gencount = fattr->gencount;
535 if (fattr->valid & NFS_ATTR_FATTR_ATIME)
536 inode->i_atime = fattr->atime;
537 else if (fattr_supported & NFS_ATTR_FATTR_ATIME)
538 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
539 if (fattr->valid & NFS_ATTR_FATTR_MTIME)
540 inode->i_mtime = fattr->mtime;
541 else if (fattr_supported & NFS_ATTR_FATTR_MTIME)
542 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME);
543 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
544 inode->i_ctime = fattr->ctime;
545 else if (fattr_supported & NFS_ATTR_FATTR_CTIME)
546 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CTIME);
547 if (fattr->valid & NFS_ATTR_FATTR_CHANGE)
548 inode_set_iversion_raw(inode, fattr->change_attr);
549 else
550 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE);
551 if (fattr->valid & NFS_ATTR_FATTR_SIZE)
552 inode->i_size = nfs_size_to_loff_t(fattr->size);
553 else
554 nfs_set_cache_invalid(inode, NFS_INO_INVALID_SIZE);
555 if (fattr->valid & NFS_ATTR_FATTR_NLINK)
556 set_nlink(inode, fattr->nlink);
557 else if (fattr_supported & NFS_ATTR_FATTR_NLINK)
558 nfs_set_cache_invalid(inode, NFS_INO_INVALID_NLINK);
559 if (fattr->valid & NFS_ATTR_FATTR_OWNER)
560 inode->i_uid = fattr->uid;
561 else if (fattr_supported & NFS_ATTR_FATTR_OWNER)
562 nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
563 if (fattr->valid & NFS_ATTR_FATTR_GROUP)
564 inode->i_gid = fattr->gid;
565 else if (fattr_supported & NFS_ATTR_FATTR_GROUP)
566 nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
567 if (nfs_server_capable(inode, NFS_CAP_XATTR))
568 nfs_set_cache_invalid(inode, NFS_INO_INVALID_XATTR);
569 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
570 inode->i_blocks = fattr->du.nfs2.blocks;
571 else if (fattr_supported & NFS_ATTR_FATTR_BLOCKS_USED &&
572 fattr->size != 0)
573 nfs_set_cache_invalid(inode, NFS_INO_INVALID_BLOCKS);
574 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
575 /*
576 * report the blocks in 512byte units
577 */
578 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
579 } else if (fattr_supported & NFS_ATTR_FATTR_SPACE_USED &&
580 fattr->size != 0)
581 nfs_set_cache_invalid(inode, NFS_INO_INVALID_BLOCKS);
582
583 nfs_setsecurity(inode, fattr);
584
585 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
586 nfsi->attrtimeo_timestamp = now;
587 nfsi->access_cache = RB_ROOT;
588
589 nfs_fscache_init_inode(inode);
590
591 unlock_new_inode(inode);
592 } else {
593 int err = nfs_refresh_inode(inode, fattr);
594 if (err < 0) {
595 iput(inode);
596 inode = ERR_PTR(err);
597 goto out_no_inode;
598 }
599 }
600 dprintk("NFS: nfs_fhget(%s/%Lu fh_crc=0x%08x ct=%d)\n",
601 inode->i_sb->s_id,
602 (unsigned long long)NFS_FILEID(inode),
603 nfs_display_fhandle_hash(fh),
604 atomic_read(&inode->i_count));
605
606 out:
607 return inode;
608
609 out_no_inode:
610 dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
611 goto out;
612 }
613 EXPORT_SYMBOL_GPL(nfs_fhget);
614
615 #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)
616
617 int
nfs_setattr(struct user_namespace * mnt_userns,struct dentry * dentry,struct iattr * attr)618 nfs_setattr(struct user_namespace *mnt_userns, struct dentry *dentry,
619 struct iattr *attr)
620 {
621 struct inode *inode = d_inode(dentry);
622 struct nfs_fattr *fattr;
623 int error = 0;
624
625 nfs_inc_stats(inode, NFSIOS_VFSSETATTR);
626
627 /* skip mode change if it's just for clearing setuid/setgid */
628 if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
629 attr->ia_valid &= ~ATTR_MODE;
630
631 if (attr->ia_valid & ATTR_SIZE) {
632 BUG_ON(!S_ISREG(inode->i_mode));
633
634 error = inode_newsize_ok(inode, attr->ia_size);
635 if (error)
636 return error;
637
638 if (attr->ia_size == i_size_read(inode))
639 attr->ia_valid &= ~ATTR_SIZE;
640 }
641
642 /* Optimization: if the end result is no change, don't RPC */
643 if (((attr->ia_valid & NFS_VALID_ATTRS) & ~(ATTR_FILE|ATTR_OPEN)) == 0)
644 return 0;
645
646 trace_nfs_setattr_enter(inode);
647
648 /* Write all dirty data */
649 if (S_ISREG(inode->i_mode))
650 nfs_sync_inode(inode);
651
652 fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode));
653 if (fattr == NULL) {
654 error = -ENOMEM;
655 goto out;
656 }
657
658 error = NFS_PROTO(inode)->setattr(dentry, fattr, attr);
659 if (error == 0)
660 error = nfs_refresh_inode(inode, fattr);
661 nfs_free_fattr(fattr);
662 out:
663 trace_nfs_setattr_exit(inode, error);
664 return error;
665 }
666 EXPORT_SYMBOL_GPL(nfs_setattr);
667
668 /**
669 * nfs_vmtruncate - unmap mappings "freed" by truncate() syscall
670 * @inode: inode of the file used
671 * @offset: file offset to start truncating
672 *
673 * This is a copy of the common vmtruncate, but with the locking
674 * corrected to take into account the fact that NFS requires
675 * inode->i_size to be updated under the inode->i_lock.
676 * Note: must be called with inode->i_lock held!
677 */
nfs_vmtruncate(struct inode * inode,loff_t offset)678 static int nfs_vmtruncate(struct inode * inode, loff_t offset)
679 {
680 int err;
681
682 err = inode_newsize_ok(inode, offset);
683 if (err)
684 goto out;
685
686 trace_nfs_size_truncate(inode, offset);
687 i_size_write(inode, offset);
688 /* Optimisation */
689 if (offset == 0)
690 NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_DATA |
691 NFS_INO_DATA_INVAL_DEFER);
692 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_SIZE;
693
694 spin_unlock(&inode->i_lock);
695 truncate_pagecache(inode, offset);
696 spin_lock(&inode->i_lock);
697 out:
698 return err;
699 }
700
701 /**
702 * nfs_setattr_update_inode - Update inode metadata after a setattr call.
703 * @inode: pointer to struct inode
704 * @attr: pointer to struct iattr
705 * @fattr: pointer to struct nfs_fattr
706 *
707 * Note: we do this in the *proc.c in order to ensure that
708 * it works for things like exclusive creates too.
709 */
nfs_setattr_update_inode(struct inode * inode,struct iattr * attr,struct nfs_fattr * fattr)710 void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr,
711 struct nfs_fattr *fattr)
712 {
713 /* Barrier: bump the attribute generation count. */
714 nfs_fattr_set_barrier(fattr);
715
716 spin_lock(&inode->i_lock);
717 NFS_I(inode)->attr_gencount = fattr->gencount;
718 if ((attr->ia_valid & ATTR_SIZE) != 0) {
719 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME |
720 NFS_INO_INVALID_BLOCKS);
721 nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
722 nfs_vmtruncate(inode, attr->ia_size);
723 }
724 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) {
725 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_CTIME;
726 if ((attr->ia_valid & ATTR_KILL_SUID) != 0 &&
727 inode->i_mode & S_ISUID)
728 inode->i_mode &= ~S_ISUID;
729 if ((attr->ia_valid & ATTR_KILL_SGID) != 0 &&
730 (inode->i_mode & (S_ISGID | S_IXGRP)) ==
731 (S_ISGID | S_IXGRP))
732 inode->i_mode &= ~S_ISGID;
733 if ((attr->ia_valid & ATTR_MODE) != 0) {
734 int mode = attr->ia_mode & S_IALLUGO;
735 mode |= inode->i_mode & ~S_IALLUGO;
736 inode->i_mode = mode;
737 }
738 if ((attr->ia_valid & ATTR_UID) != 0)
739 inode->i_uid = attr->ia_uid;
740 if ((attr->ia_valid & ATTR_GID) != 0)
741 inode->i_gid = attr->ia_gid;
742 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
743 inode->i_ctime = fattr->ctime;
744 else
745 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE
746 | NFS_INO_INVALID_CTIME);
747 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ACCESS
748 | NFS_INO_INVALID_ACL);
749 }
750 if (attr->ia_valid & (ATTR_ATIME_SET|ATTR_ATIME)) {
751 NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_ATIME
752 | NFS_INO_INVALID_CTIME);
753 if (fattr->valid & NFS_ATTR_FATTR_ATIME)
754 inode->i_atime = fattr->atime;
755 else if (attr->ia_valid & ATTR_ATIME_SET)
756 inode->i_atime = attr->ia_atime;
757 else
758 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
759
760 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
761 inode->i_ctime = fattr->ctime;
762 else
763 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE
764 | NFS_INO_INVALID_CTIME);
765 }
766 if (attr->ia_valid & (ATTR_MTIME_SET|ATTR_MTIME)) {
767 NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_MTIME
768 | NFS_INO_INVALID_CTIME);
769 if (fattr->valid & NFS_ATTR_FATTR_MTIME)
770 inode->i_mtime = fattr->mtime;
771 else if (attr->ia_valid & ATTR_MTIME_SET)
772 inode->i_mtime = attr->ia_mtime;
773 else
774 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME);
775
776 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
777 inode->i_ctime = fattr->ctime;
778 else
779 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE
780 | NFS_INO_INVALID_CTIME);
781 }
782 if (fattr->valid)
783 nfs_update_inode(inode, fattr);
784 spin_unlock(&inode->i_lock);
785 }
786 EXPORT_SYMBOL_GPL(nfs_setattr_update_inode);
787
nfs_readdirplus_parent_cache_miss(struct dentry * dentry)788 static void nfs_readdirplus_parent_cache_miss(struct dentry *dentry)
789 {
790 struct dentry *parent;
791
792 if (!nfs_server_capable(d_inode(dentry), NFS_CAP_READDIRPLUS))
793 return;
794 parent = dget_parent(dentry);
795 nfs_force_use_readdirplus(d_inode(parent));
796 dput(parent);
797 }
798
nfs_readdirplus_parent_cache_hit(struct dentry * dentry)799 static void nfs_readdirplus_parent_cache_hit(struct dentry *dentry)
800 {
801 struct dentry *parent;
802
803 if (!nfs_server_capable(d_inode(dentry), NFS_CAP_READDIRPLUS))
804 return;
805 parent = dget_parent(dentry);
806 nfs_advise_use_readdirplus(d_inode(parent));
807 dput(parent);
808 }
809
nfs_get_valid_attrmask(struct inode * inode)810 static u32 nfs_get_valid_attrmask(struct inode *inode)
811 {
812 unsigned long cache_validity = READ_ONCE(NFS_I(inode)->cache_validity);
813 u32 reply_mask = STATX_INO | STATX_TYPE;
814
815 if (!(cache_validity & NFS_INO_INVALID_ATIME))
816 reply_mask |= STATX_ATIME;
817 if (!(cache_validity & NFS_INO_INVALID_CTIME))
818 reply_mask |= STATX_CTIME;
819 if (!(cache_validity & NFS_INO_INVALID_MTIME))
820 reply_mask |= STATX_MTIME;
821 if (!(cache_validity & NFS_INO_INVALID_SIZE))
822 reply_mask |= STATX_SIZE;
823 if (!(cache_validity & NFS_INO_INVALID_NLINK))
824 reply_mask |= STATX_NLINK;
825 if (!(cache_validity & NFS_INO_INVALID_MODE))
826 reply_mask |= STATX_MODE;
827 if (!(cache_validity & NFS_INO_INVALID_OTHER))
828 reply_mask |= STATX_UID | STATX_GID;
829 if (!(cache_validity & NFS_INO_INVALID_BLOCKS))
830 reply_mask |= STATX_BLOCKS;
831 return reply_mask;
832 }
833
nfs_getattr(struct user_namespace * mnt_userns,const struct path * path,struct kstat * stat,u32 request_mask,unsigned int query_flags)834 int nfs_getattr(struct user_namespace *mnt_userns, const struct path *path,
835 struct kstat *stat, u32 request_mask, unsigned int query_flags)
836 {
837 struct inode *inode = d_inode(path->dentry);
838 struct nfs_server *server = NFS_SERVER(inode);
839 unsigned long cache_validity;
840 int err = 0;
841 bool force_sync = query_flags & AT_STATX_FORCE_SYNC;
842 bool do_update = false;
843
844 trace_nfs_getattr_enter(inode);
845
846 request_mask &= STATX_TYPE | STATX_MODE | STATX_NLINK | STATX_UID |
847 STATX_GID | STATX_ATIME | STATX_MTIME | STATX_CTIME |
848 STATX_INO | STATX_SIZE | STATX_BLOCKS;
849
850 if ((query_flags & AT_STATX_DONT_SYNC) && !force_sync) {
851 nfs_readdirplus_parent_cache_hit(path->dentry);
852 goto out_no_revalidate;
853 }
854
855 /* Flush out writes to the server in order to update c/mtime. */
856 if ((request_mask & (STATX_CTIME|STATX_MTIME)) &&
857 S_ISREG(inode->i_mode)) {
858 err = filemap_write_and_wait(inode->i_mapping);
859 if (err)
860 goto out;
861 }
862
863 /*
864 * We may force a getattr if the user cares about atime.
865 *
866 * Note that we only have to check the vfsmount flags here:
867 * - NFS always sets S_NOATIME by so checking it would give a
868 * bogus result
869 * - NFS never sets SB_NOATIME or SB_NODIRATIME so there is
870 * no point in checking those.
871 */
872 if ((path->mnt->mnt_flags & MNT_NOATIME) ||
873 ((path->mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
874 request_mask &= ~STATX_ATIME;
875
876 /* Is the user requesting attributes that might need revalidation? */
877 if (!(request_mask & (STATX_MODE|STATX_NLINK|STATX_ATIME|STATX_CTIME|
878 STATX_MTIME|STATX_UID|STATX_GID|
879 STATX_SIZE|STATX_BLOCKS)))
880 goto out_no_revalidate;
881
882 /* Check whether the cached attributes are stale */
883 do_update |= force_sync || nfs_attribute_cache_expired(inode);
884 cache_validity = READ_ONCE(NFS_I(inode)->cache_validity);
885 do_update |= cache_validity & NFS_INO_INVALID_CHANGE;
886 if (request_mask & STATX_ATIME)
887 do_update |= cache_validity & NFS_INO_INVALID_ATIME;
888 if (request_mask & STATX_CTIME)
889 do_update |= cache_validity & NFS_INO_INVALID_CTIME;
890 if (request_mask & STATX_MTIME)
891 do_update |= cache_validity & NFS_INO_INVALID_MTIME;
892 if (request_mask & STATX_SIZE)
893 do_update |= cache_validity & NFS_INO_INVALID_SIZE;
894 if (request_mask & STATX_NLINK)
895 do_update |= cache_validity & NFS_INO_INVALID_NLINK;
896 if (request_mask & STATX_MODE)
897 do_update |= cache_validity & NFS_INO_INVALID_MODE;
898 if (request_mask & (STATX_UID | STATX_GID))
899 do_update |= cache_validity & NFS_INO_INVALID_OTHER;
900 if (request_mask & STATX_BLOCKS)
901 do_update |= cache_validity & NFS_INO_INVALID_BLOCKS;
902
903 if (do_update) {
904 /* Update the attribute cache */
905 if (!(server->flags & NFS_MOUNT_NOAC))
906 nfs_readdirplus_parent_cache_miss(path->dentry);
907 else
908 nfs_readdirplus_parent_cache_hit(path->dentry);
909 err = __nfs_revalidate_inode(server, inode);
910 if (err)
911 goto out;
912 } else
913 nfs_readdirplus_parent_cache_hit(path->dentry);
914 out_no_revalidate:
915 /* Only return attributes that were revalidated. */
916 stat->result_mask = nfs_get_valid_attrmask(inode) | request_mask;
917
918 generic_fillattr(&init_user_ns, inode, stat);
919 stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
920 if (S_ISDIR(inode->i_mode))
921 stat->blksize = NFS_SERVER(inode)->dtsize;
922 out:
923 trace_nfs_getattr_exit(inode, err);
924 return err;
925 }
926 EXPORT_SYMBOL_GPL(nfs_getattr);
927
nfs_init_lock_context(struct nfs_lock_context * l_ctx)928 static void nfs_init_lock_context(struct nfs_lock_context *l_ctx)
929 {
930 refcount_set(&l_ctx->count, 1);
931 l_ctx->lockowner = current->files;
932 INIT_LIST_HEAD(&l_ctx->list);
933 atomic_set(&l_ctx->io_count, 0);
934 }
935
__nfs_find_lock_context(struct nfs_open_context * ctx)936 static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context *ctx)
937 {
938 struct nfs_lock_context *pos;
939
940 list_for_each_entry_rcu(pos, &ctx->lock_context.list, list) {
941 if (pos->lockowner != current->files)
942 continue;
943 if (refcount_inc_not_zero(&pos->count))
944 return pos;
945 }
946 return NULL;
947 }
948
nfs_get_lock_context(struct nfs_open_context * ctx)949 struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx)
950 {
951 struct nfs_lock_context *res, *new = NULL;
952 struct inode *inode = d_inode(ctx->dentry);
953
954 rcu_read_lock();
955 res = __nfs_find_lock_context(ctx);
956 rcu_read_unlock();
957 if (res == NULL) {
958 new = kmalloc(sizeof(*new), GFP_KERNEL);
959 if (new == NULL)
960 return ERR_PTR(-ENOMEM);
961 nfs_init_lock_context(new);
962 spin_lock(&inode->i_lock);
963 res = __nfs_find_lock_context(ctx);
964 if (res == NULL) {
965 new->open_context = get_nfs_open_context(ctx);
966 if (new->open_context) {
967 list_add_tail_rcu(&new->list,
968 &ctx->lock_context.list);
969 res = new;
970 new = NULL;
971 } else
972 res = ERR_PTR(-EBADF);
973 }
974 spin_unlock(&inode->i_lock);
975 kfree(new);
976 }
977 return res;
978 }
979 EXPORT_SYMBOL_GPL(nfs_get_lock_context);
980
nfs_put_lock_context(struct nfs_lock_context * l_ctx)981 void nfs_put_lock_context(struct nfs_lock_context *l_ctx)
982 {
983 struct nfs_open_context *ctx = l_ctx->open_context;
984 struct inode *inode = d_inode(ctx->dentry);
985
986 if (!refcount_dec_and_lock(&l_ctx->count, &inode->i_lock))
987 return;
988 list_del_rcu(&l_ctx->list);
989 spin_unlock(&inode->i_lock);
990 put_nfs_open_context(ctx);
991 kfree_rcu(l_ctx, rcu_head);
992 }
993 EXPORT_SYMBOL_GPL(nfs_put_lock_context);
994
995 /**
996 * nfs_close_context - Common close_context() routine NFSv2/v3
997 * @ctx: pointer to context
998 * @is_sync: is this a synchronous close
999 *
1000 * Ensure that the attributes are up to date if we're mounted
1001 * with close-to-open semantics and we have cached data that will
1002 * need to be revalidated on open.
1003 */
nfs_close_context(struct nfs_open_context * ctx,int is_sync)1004 void nfs_close_context(struct nfs_open_context *ctx, int is_sync)
1005 {
1006 struct nfs_inode *nfsi;
1007 struct inode *inode;
1008
1009 if (!(ctx->mode & FMODE_WRITE))
1010 return;
1011 if (!is_sync)
1012 return;
1013 inode = d_inode(ctx->dentry);
1014 if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
1015 return;
1016 nfsi = NFS_I(inode);
1017 if (inode->i_mapping->nrpages == 0)
1018 return;
1019 if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
1020 return;
1021 if (!list_empty(&nfsi->open_files))
1022 return;
1023 if (NFS_SERVER(inode)->flags & NFS_MOUNT_NOCTO)
1024 return;
1025 nfs_revalidate_inode(inode,
1026 NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_SIZE);
1027 }
1028 EXPORT_SYMBOL_GPL(nfs_close_context);
1029
alloc_nfs_open_context(struct dentry * dentry,fmode_t f_mode,struct file * filp)1030 struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry,
1031 fmode_t f_mode,
1032 struct file *filp)
1033 {
1034 struct nfs_open_context *ctx;
1035
1036 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
1037 if (!ctx)
1038 return ERR_PTR(-ENOMEM);
1039 nfs_sb_active(dentry->d_sb);
1040 ctx->dentry = dget(dentry);
1041 if (filp)
1042 ctx->cred = get_cred(filp->f_cred);
1043 else
1044 ctx->cred = get_current_cred();
1045 rcu_assign_pointer(ctx->ll_cred, NULL);
1046 ctx->state = NULL;
1047 ctx->mode = f_mode;
1048 ctx->flags = 0;
1049 ctx->error = 0;
1050 ctx->flock_owner = (fl_owner_t)filp;
1051 nfs_init_lock_context(&ctx->lock_context);
1052 ctx->lock_context.open_context = ctx;
1053 INIT_LIST_HEAD(&ctx->list);
1054 ctx->mdsthreshold = NULL;
1055 return ctx;
1056 }
1057 EXPORT_SYMBOL_GPL(alloc_nfs_open_context);
1058
get_nfs_open_context(struct nfs_open_context * ctx)1059 struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
1060 {
1061 if (ctx != NULL && refcount_inc_not_zero(&ctx->lock_context.count))
1062 return ctx;
1063 return NULL;
1064 }
1065 EXPORT_SYMBOL_GPL(get_nfs_open_context);
1066
__put_nfs_open_context(struct nfs_open_context * ctx,int is_sync)1067 static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
1068 {
1069 struct inode *inode = d_inode(ctx->dentry);
1070 struct super_block *sb = ctx->dentry->d_sb;
1071
1072 if (!refcount_dec_and_test(&ctx->lock_context.count))
1073 return;
1074 if (!list_empty(&ctx->list)) {
1075 spin_lock(&inode->i_lock);
1076 list_del_rcu(&ctx->list);
1077 spin_unlock(&inode->i_lock);
1078 }
1079 if (inode != NULL)
1080 NFS_PROTO(inode)->close_context(ctx, is_sync);
1081 put_cred(ctx->cred);
1082 dput(ctx->dentry);
1083 nfs_sb_deactive(sb);
1084 put_rpccred(rcu_dereference_protected(ctx->ll_cred, 1));
1085 kfree(ctx->mdsthreshold);
1086 kfree_rcu(ctx, rcu_head);
1087 }
1088
put_nfs_open_context(struct nfs_open_context * ctx)1089 void put_nfs_open_context(struct nfs_open_context *ctx)
1090 {
1091 __put_nfs_open_context(ctx, 0);
1092 }
1093 EXPORT_SYMBOL_GPL(put_nfs_open_context);
1094
put_nfs_open_context_sync(struct nfs_open_context * ctx)1095 static void put_nfs_open_context_sync(struct nfs_open_context *ctx)
1096 {
1097 __put_nfs_open_context(ctx, 1);
1098 }
1099
1100 /*
1101 * Ensure that mmap has a recent RPC credential for use when writing out
1102 * shared pages
1103 */
nfs_inode_attach_open_context(struct nfs_open_context * ctx)1104 void nfs_inode_attach_open_context(struct nfs_open_context *ctx)
1105 {
1106 struct inode *inode = d_inode(ctx->dentry);
1107 struct nfs_inode *nfsi = NFS_I(inode);
1108
1109 spin_lock(&inode->i_lock);
1110 if (list_empty(&nfsi->open_files) &&
1111 (nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER))
1112 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA |
1113 NFS_INO_REVAL_FORCED);
1114 list_add_tail_rcu(&ctx->list, &nfsi->open_files);
1115 spin_unlock(&inode->i_lock);
1116 }
1117 EXPORT_SYMBOL_GPL(nfs_inode_attach_open_context);
1118
nfs_file_set_open_context(struct file * filp,struct nfs_open_context * ctx)1119 void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
1120 {
1121 filp->private_data = get_nfs_open_context(ctx);
1122 set_bit(NFS_CONTEXT_FILE_OPEN, &ctx->flags);
1123 if (list_empty(&ctx->list))
1124 nfs_inode_attach_open_context(ctx);
1125 }
1126 EXPORT_SYMBOL_GPL(nfs_file_set_open_context);
1127
1128 /*
1129 * Given an inode, search for an open context with the desired characteristics
1130 */
nfs_find_open_context(struct inode * inode,const struct cred * cred,fmode_t mode)1131 struct nfs_open_context *nfs_find_open_context(struct inode *inode, const struct cred *cred, fmode_t mode)
1132 {
1133 struct nfs_inode *nfsi = NFS_I(inode);
1134 struct nfs_open_context *pos, *ctx = NULL;
1135
1136 rcu_read_lock();
1137 list_for_each_entry_rcu(pos, &nfsi->open_files, list) {
1138 if (cred != NULL && cred_fscmp(pos->cred, cred) != 0)
1139 continue;
1140 if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode)
1141 continue;
1142 if (!test_bit(NFS_CONTEXT_FILE_OPEN, &pos->flags))
1143 continue;
1144 ctx = get_nfs_open_context(pos);
1145 if (ctx)
1146 break;
1147 }
1148 rcu_read_unlock();
1149 return ctx;
1150 }
1151
nfs_file_clear_open_context(struct file * filp)1152 void nfs_file_clear_open_context(struct file *filp)
1153 {
1154 struct nfs_open_context *ctx = nfs_file_open_context(filp);
1155
1156 if (ctx) {
1157 struct inode *inode = d_inode(ctx->dentry);
1158
1159 clear_bit(NFS_CONTEXT_FILE_OPEN, &ctx->flags);
1160 /*
1161 * We fatal error on write before. Try to writeback
1162 * every page again.
1163 */
1164 if (ctx->error < 0)
1165 invalidate_inode_pages2(inode->i_mapping);
1166 filp->private_data = NULL;
1167 put_nfs_open_context_sync(ctx);
1168 }
1169 }
1170
1171 /*
1172 * These allocate and release file read/write context information.
1173 */
nfs_open(struct inode * inode,struct file * filp)1174 int nfs_open(struct inode *inode, struct file *filp)
1175 {
1176 struct nfs_open_context *ctx;
1177
1178 ctx = alloc_nfs_open_context(file_dentry(filp), filp->f_mode, filp);
1179 if (IS_ERR(ctx))
1180 return PTR_ERR(ctx);
1181 nfs_file_set_open_context(filp, ctx);
1182 put_nfs_open_context(ctx);
1183 nfs_fscache_open_file(inode, filp);
1184 return 0;
1185 }
1186 EXPORT_SYMBOL_GPL(nfs_open);
1187
1188 /*
1189 * This function is called whenever some part of NFS notices that
1190 * the cached attributes have to be refreshed.
1191 */
1192 int
__nfs_revalidate_inode(struct nfs_server * server,struct inode * inode)1193 __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
1194 {
1195 int status = -ESTALE;
1196 struct nfs_fattr *fattr = NULL;
1197 struct nfs_inode *nfsi = NFS_I(inode);
1198
1199 dfprintk(PAGECACHE, "NFS: revalidating (%s/%Lu)\n",
1200 inode->i_sb->s_id, (unsigned long long)NFS_FILEID(inode));
1201
1202 trace_nfs_revalidate_inode_enter(inode);
1203
1204 if (is_bad_inode(inode))
1205 goto out;
1206 if (NFS_STALE(inode))
1207 goto out;
1208
1209 /* pNFS: Attributes aren't updated until we layoutcommit */
1210 if (S_ISREG(inode->i_mode)) {
1211 status = pnfs_sync_inode(inode, false);
1212 if (status)
1213 goto out;
1214 }
1215
1216 status = -ENOMEM;
1217 fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode));
1218 if (fattr == NULL)
1219 goto out;
1220
1221 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
1222
1223 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, inode);
1224 if (status != 0) {
1225 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) getattr failed, error=%d\n",
1226 inode->i_sb->s_id,
1227 (unsigned long long)NFS_FILEID(inode), status);
1228 switch (status) {
1229 case -ETIMEDOUT:
1230 /* A soft timeout occurred. Use cached information? */
1231 if (server->flags & NFS_MOUNT_SOFTREVAL)
1232 status = 0;
1233 break;
1234 case -ESTALE:
1235 if (!S_ISDIR(inode->i_mode))
1236 nfs_set_inode_stale(inode);
1237 else
1238 nfs_zap_caches(inode);
1239 }
1240 goto out;
1241 }
1242
1243 status = nfs_refresh_inode(inode, fattr);
1244 if (status) {
1245 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) refresh failed, error=%d\n",
1246 inode->i_sb->s_id,
1247 (unsigned long long)NFS_FILEID(inode), status);
1248 goto out;
1249 }
1250
1251 if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
1252 nfs_zap_acl_cache(inode);
1253
1254 nfs_setsecurity(inode, fattr);
1255
1256 dfprintk(PAGECACHE, "NFS: (%s/%Lu) revalidation complete\n",
1257 inode->i_sb->s_id,
1258 (unsigned long long)NFS_FILEID(inode));
1259
1260 out:
1261 nfs_free_fattr(fattr);
1262 trace_nfs_revalidate_inode_exit(inode, status);
1263 return status;
1264 }
1265
nfs_attribute_cache_expired(struct inode * inode)1266 int nfs_attribute_cache_expired(struct inode *inode)
1267 {
1268 if (nfs_have_delegated_attributes(inode))
1269 return 0;
1270 return nfs_attribute_timeout(inode);
1271 }
1272
1273 /**
1274 * nfs_revalidate_inode - Revalidate the inode attributes
1275 * @inode: pointer to inode struct
1276 * @flags: cache flags to check
1277 *
1278 * Updates inode attribute information by retrieving the data from the server.
1279 */
nfs_revalidate_inode(struct inode * inode,unsigned long flags)1280 int nfs_revalidate_inode(struct inode *inode, unsigned long flags)
1281 {
1282 if (!nfs_check_cache_invalid(inode, flags))
1283 return NFS_STALE(inode) ? -ESTALE : 0;
1284 return __nfs_revalidate_inode(NFS_SERVER(inode), inode);
1285 }
1286 EXPORT_SYMBOL_GPL(nfs_revalidate_inode);
1287
nfs_invalidate_mapping(struct inode * inode,struct address_space * mapping)1288 static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
1289 {
1290 int ret;
1291
1292 if (mapping->nrpages != 0) {
1293 if (S_ISREG(inode->i_mode)) {
1294 ret = nfs_sync_mapping(mapping);
1295 if (ret < 0)
1296 return ret;
1297 }
1298 ret = invalidate_inode_pages2(mapping);
1299 if (ret < 0)
1300 return ret;
1301 }
1302 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
1303 nfs_fscache_wait_on_invalidate(inode);
1304
1305 dfprintk(PAGECACHE, "NFS: (%s/%Lu) data cache invalidated\n",
1306 inode->i_sb->s_id,
1307 (unsigned long long)NFS_FILEID(inode));
1308 return 0;
1309 }
1310
1311 /**
1312 * nfs_clear_invalid_mapping - Conditionally clear a mapping
1313 * @mapping: pointer to mapping
1314 *
1315 * If the NFS_INO_INVALID_DATA inode flag is set, clear the mapping.
1316 */
nfs_clear_invalid_mapping(struct address_space * mapping)1317 int nfs_clear_invalid_mapping(struct address_space *mapping)
1318 {
1319 struct inode *inode = mapping->host;
1320 struct nfs_inode *nfsi = NFS_I(inode);
1321 unsigned long *bitlock = &nfsi->flags;
1322 int ret = 0;
1323
1324 /*
1325 * We must clear NFS_INO_INVALID_DATA first to ensure that
1326 * invalidations that come in while we're shooting down the mappings
1327 * are respected. But, that leaves a race window where one revalidator
1328 * can clear the flag, and then another checks it before the mapping
1329 * gets invalidated. Fix that by serializing access to this part of
1330 * the function.
1331 *
1332 * At the same time, we need to allow other tasks to see whether we
1333 * might be in the middle of invalidating the pages, so we only set
1334 * the bit lock here if it looks like we're going to be doing that.
1335 */
1336 for (;;) {
1337 ret = wait_on_bit_action(bitlock, NFS_INO_INVALIDATING,
1338 nfs_wait_bit_killable, TASK_KILLABLE);
1339 if (ret)
1340 goto out;
1341 spin_lock(&inode->i_lock);
1342 if (test_bit(NFS_INO_INVALIDATING, bitlock)) {
1343 spin_unlock(&inode->i_lock);
1344 continue;
1345 }
1346 if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
1347 break;
1348 spin_unlock(&inode->i_lock);
1349 goto out;
1350 }
1351
1352 set_bit(NFS_INO_INVALIDATING, bitlock);
1353 smp_wmb();
1354 nfsi->cache_validity &=
1355 ~(NFS_INO_INVALID_DATA | NFS_INO_DATA_INVAL_DEFER);
1356 spin_unlock(&inode->i_lock);
1357 trace_nfs_invalidate_mapping_enter(inode);
1358 ret = nfs_invalidate_mapping(inode, mapping);
1359 trace_nfs_invalidate_mapping_exit(inode, ret);
1360
1361 clear_bit_unlock(NFS_INO_INVALIDATING, bitlock);
1362 smp_mb__after_atomic();
1363 wake_up_bit(bitlock, NFS_INO_INVALIDATING);
1364 out:
1365 return ret;
1366 }
1367
nfs_mapping_need_revalidate_inode(struct inode * inode)1368 bool nfs_mapping_need_revalidate_inode(struct inode *inode)
1369 {
1370 return nfs_check_cache_invalid(inode, NFS_INO_INVALID_CHANGE) ||
1371 NFS_STALE(inode);
1372 }
1373
nfs_revalidate_mapping_rcu(struct inode * inode)1374 int nfs_revalidate_mapping_rcu(struct inode *inode)
1375 {
1376 struct nfs_inode *nfsi = NFS_I(inode);
1377 unsigned long *bitlock = &nfsi->flags;
1378 int ret = 0;
1379
1380 if (IS_SWAPFILE(inode))
1381 goto out;
1382 if (nfs_mapping_need_revalidate_inode(inode)) {
1383 ret = -ECHILD;
1384 goto out;
1385 }
1386 spin_lock(&inode->i_lock);
1387 if (test_bit(NFS_INO_INVALIDATING, bitlock) ||
1388 (nfsi->cache_validity & NFS_INO_INVALID_DATA))
1389 ret = -ECHILD;
1390 spin_unlock(&inode->i_lock);
1391 out:
1392 return ret;
1393 }
1394
1395 /**
1396 * nfs_revalidate_mapping - Revalidate the pagecache
1397 * @inode: pointer to host inode
1398 * @mapping: pointer to mapping
1399 */
nfs_revalidate_mapping(struct inode * inode,struct address_space * mapping)1400 int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
1401 {
1402 /* swapfiles are not supposed to be shared. */
1403 if (IS_SWAPFILE(inode))
1404 return 0;
1405
1406 if (nfs_mapping_need_revalidate_inode(inode)) {
1407 int ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
1408 if (ret < 0)
1409 return ret;
1410 }
1411
1412 return nfs_clear_invalid_mapping(mapping);
1413 }
1414
nfs_file_has_writers(struct nfs_inode * nfsi)1415 static bool nfs_file_has_writers(struct nfs_inode *nfsi)
1416 {
1417 struct inode *inode = &nfsi->vfs_inode;
1418
1419 if (!S_ISREG(inode->i_mode))
1420 return false;
1421 if (list_empty(&nfsi->open_files))
1422 return false;
1423 return inode_is_open_for_write(inode);
1424 }
1425
nfs_file_has_buffered_writers(struct nfs_inode * nfsi)1426 static bool nfs_file_has_buffered_writers(struct nfs_inode *nfsi)
1427 {
1428 return nfs_file_has_writers(nfsi) && nfs_file_io_is_buffered(nfsi);
1429 }
1430
nfs_wcc_update_inode(struct inode * inode,struct nfs_fattr * fattr)1431 static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1432 {
1433 struct timespec64 ts;
1434
1435 if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE)
1436 && (fattr->valid & NFS_ATTR_FATTR_CHANGE)
1437 && inode_eq_iversion_raw(inode, fattr->pre_change_attr)) {
1438 inode_set_iversion_raw(inode, fattr->change_attr);
1439 if (S_ISDIR(inode->i_mode))
1440 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
1441 else if (nfs_server_capable(inode, NFS_CAP_XATTR))
1442 nfs_set_cache_invalid(inode, NFS_INO_INVALID_XATTR);
1443 }
1444 /* If we have atomic WCC data, we may update some attributes */
1445 ts = inode->i_ctime;
1446 if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME)
1447 && (fattr->valid & NFS_ATTR_FATTR_CTIME)
1448 && timespec64_equal(&ts, &fattr->pre_ctime)) {
1449 inode->i_ctime = fattr->ctime;
1450 }
1451
1452 ts = inode->i_mtime;
1453 if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME)
1454 && (fattr->valid & NFS_ATTR_FATTR_MTIME)
1455 && timespec64_equal(&ts, &fattr->pre_mtime)) {
1456 inode->i_mtime = fattr->mtime;
1457 }
1458 if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE)
1459 && (fattr->valid & NFS_ATTR_FATTR_SIZE)
1460 && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size)
1461 && !nfs_have_writebacks(inode)) {
1462 trace_nfs_size_wcc(inode, fattr->size);
1463 i_size_write(inode, nfs_size_to_loff_t(fattr->size));
1464 }
1465 }
1466
1467 /**
1468 * nfs_check_inode_attributes - verify consistency of the inode attribute cache
1469 * @inode: pointer to inode
1470 * @fattr: updated attributes
1471 *
1472 * Verifies the attribute cache. If we have just changed the attributes,
1473 * so that fattr carries weak cache consistency data, then it may
1474 * also update the ctime/mtime/change_attribute.
1475 */
nfs_check_inode_attributes(struct inode * inode,struct nfs_fattr * fattr)1476 static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
1477 {
1478 struct nfs_inode *nfsi = NFS_I(inode);
1479 loff_t cur_size, new_isize;
1480 unsigned long invalid = 0;
1481 struct timespec64 ts;
1482
1483 if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
1484 return 0;
1485
1486 if (!(fattr->valid & NFS_ATTR_FATTR_FILEID)) {
1487 /* Only a mounted-on-fileid? Just exit */
1488 if (fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
1489 return 0;
1490 /* Has the inode gone and changed behind our back? */
1491 } else if (nfsi->fileid != fattr->fileid) {
1492 /* Is this perhaps the mounted-on fileid? */
1493 if ((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) &&
1494 nfsi->fileid == fattr->mounted_on_fileid)
1495 return 0;
1496 return -ESTALE;
1497 }
1498 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && inode_wrong_type(inode, fattr->mode))
1499 return -ESTALE;
1500
1501
1502 if (!nfs_file_has_buffered_writers(nfsi)) {
1503 /* Verify a few of the more important attributes */
1504 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && !inode_eq_iversion_raw(inode, fattr->change_attr))
1505 invalid |= NFS_INO_INVALID_CHANGE;
1506
1507 ts = inode->i_mtime;
1508 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec64_equal(&ts, &fattr->mtime))
1509 invalid |= NFS_INO_INVALID_MTIME;
1510
1511 ts = inode->i_ctime;
1512 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) && !timespec64_equal(&ts, &fattr->ctime))
1513 invalid |= NFS_INO_INVALID_CTIME;
1514
1515 if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
1516 cur_size = i_size_read(inode);
1517 new_isize = nfs_size_to_loff_t(fattr->size);
1518 if (cur_size != new_isize)
1519 invalid |= NFS_INO_INVALID_SIZE;
1520 }
1521 }
1522
1523 /* Have any file permissions changed? */
1524 if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO))
1525 invalid |= NFS_INO_INVALID_MODE;
1526 if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && !uid_eq(inode->i_uid, fattr->uid))
1527 invalid |= NFS_INO_INVALID_OTHER;
1528 if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && !gid_eq(inode->i_gid, fattr->gid))
1529 invalid |= NFS_INO_INVALID_OTHER;
1530
1531 /* Has the link count changed? */
1532 if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink)
1533 invalid |= NFS_INO_INVALID_NLINK;
1534
1535 ts = inode->i_atime;
1536 if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec64_equal(&ts, &fattr->atime))
1537 invalid |= NFS_INO_INVALID_ATIME;
1538
1539 if (invalid != 0)
1540 nfs_set_cache_invalid(inode, invalid);
1541
1542 nfsi->read_cache_jiffies = fattr->time_start;
1543 return 0;
1544 }
1545
1546 static atomic_long_t nfs_attr_generation_counter;
1547
nfs_read_attr_generation_counter(void)1548 static unsigned long nfs_read_attr_generation_counter(void)
1549 {
1550 return atomic_long_read(&nfs_attr_generation_counter);
1551 }
1552
nfs_inc_attr_generation_counter(void)1553 unsigned long nfs_inc_attr_generation_counter(void)
1554 {
1555 return atomic_long_inc_return(&nfs_attr_generation_counter);
1556 }
1557 EXPORT_SYMBOL_GPL(nfs_inc_attr_generation_counter);
1558
nfs_fattr_init(struct nfs_fattr * fattr)1559 void nfs_fattr_init(struct nfs_fattr *fattr)
1560 {
1561 fattr->valid = 0;
1562 fattr->time_start = jiffies;
1563 fattr->gencount = nfs_inc_attr_generation_counter();
1564 fattr->owner_name = NULL;
1565 fattr->group_name = NULL;
1566 }
1567 EXPORT_SYMBOL_GPL(nfs_fattr_init);
1568
1569 /**
1570 * nfs_fattr_set_barrier
1571 * @fattr: attributes
1572 *
1573 * Used to set a barrier after an attribute was updated. This
1574 * barrier ensures that older attributes from RPC calls that may
1575 * have raced with our update cannot clobber these new values.
1576 * Note that you are still responsible for ensuring that other
1577 * operations which change the attribute on the server do not
1578 * collide.
1579 */
nfs_fattr_set_barrier(struct nfs_fattr * fattr)1580 void nfs_fattr_set_barrier(struct nfs_fattr *fattr)
1581 {
1582 fattr->gencount = nfs_inc_attr_generation_counter();
1583 }
1584
nfs_alloc_fattr(void)1585 struct nfs_fattr *nfs_alloc_fattr(void)
1586 {
1587 struct nfs_fattr *fattr;
1588
1589 fattr = kmalloc(sizeof(*fattr), GFP_NOFS);
1590 if (fattr != NULL) {
1591 nfs_fattr_init(fattr);
1592 fattr->label = NULL;
1593 }
1594 return fattr;
1595 }
1596 EXPORT_SYMBOL_GPL(nfs_alloc_fattr);
1597
nfs_alloc_fattr_with_label(struct nfs_server * server)1598 struct nfs_fattr *nfs_alloc_fattr_with_label(struct nfs_server *server)
1599 {
1600 struct nfs_fattr *fattr = nfs_alloc_fattr();
1601
1602 if (!fattr)
1603 return NULL;
1604
1605 fattr->label = nfs4_label_alloc(server, GFP_NOFS);
1606 if (IS_ERR(fattr->label)) {
1607 kfree(fattr);
1608 return NULL;
1609 }
1610
1611 return fattr;
1612 }
1613 EXPORT_SYMBOL_GPL(nfs_alloc_fattr_with_label);
1614
nfs_alloc_fhandle(void)1615 struct nfs_fh *nfs_alloc_fhandle(void)
1616 {
1617 struct nfs_fh *fh;
1618
1619 fh = kmalloc(sizeof(struct nfs_fh), GFP_NOFS);
1620 if (fh != NULL)
1621 fh->size = 0;
1622 return fh;
1623 }
1624 EXPORT_SYMBOL_GPL(nfs_alloc_fhandle);
1625
1626 #ifdef NFS_DEBUG
1627 /*
1628 * _nfs_display_fhandle_hash - calculate the crc32 hash for the filehandle
1629 * in the same way that wireshark does
1630 *
1631 * @fh: file handle
1632 *
1633 * For debugging only.
1634 */
_nfs_display_fhandle_hash(const struct nfs_fh * fh)1635 u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh)
1636 {
1637 /* wireshark uses 32-bit AUTODIN crc and does a bitwise
1638 * not on the result */
1639 return nfs_fhandle_hash(fh);
1640 }
1641 EXPORT_SYMBOL_GPL(_nfs_display_fhandle_hash);
1642
1643 /*
1644 * _nfs_display_fhandle - display an NFS file handle on the console
1645 *
1646 * @fh: file handle to display
1647 * @caption: display caption
1648 *
1649 * For debugging only.
1650 */
_nfs_display_fhandle(const struct nfs_fh * fh,const char * caption)1651 void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption)
1652 {
1653 unsigned short i;
1654
1655 if (fh == NULL || fh->size == 0) {
1656 printk(KERN_DEFAULT "%s at %p is empty\n", caption, fh);
1657 return;
1658 }
1659
1660 printk(KERN_DEFAULT "%s at %p is %u bytes, crc: 0x%08x:\n",
1661 caption, fh, fh->size, _nfs_display_fhandle_hash(fh));
1662 for (i = 0; i < fh->size; i += 16) {
1663 __be32 *pos = (__be32 *)&fh->data[i];
1664
1665 switch ((fh->size - i - 1) >> 2) {
1666 case 0:
1667 printk(KERN_DEFAULT " %08x\n",
1668 be32_to_cpup(pos));
1669 break;
1670 case 1:
1671 printk(KERN_DEFAULT " %08x %08x\n",
1672 be32_to_cpup(pos), be32_to_cpup(pos + 1));
1673 break;
1674 case 2:
1675 printk(KERN_DEFAULT " %08x %08x %08x\n",
1676 be32_to_cpup(pos), be32_to_cpup(pos + 1),
1677 be32_to_cpup(pos + 2));
1678 break;
1679 default:
1680 printk(KERN_DEFAULT " %08x %08x %08x %08x\n",
1681 be32_to_cpup(pos), be32_to_cpup(pos + 1),
1682 be32_to_cpup(pos + 2), be32_to_cpup(pos + 3));
1683 }
1684 }
1685 }
1686 EXPORT_SYMBOL_GPL(_nfs_display_fhandle);
1687 #endif
1688
1689 /**
1690 * nfs_inode_attrs_cmp_generic - compare attributes
1691 * @fattr: attributes
1692 * @inode: pointer to inode
1693 *
1694 * Attempt to divine whether or not an RPC call reply carrying stale
1695 * attributes got scheduled after another call carrying updated ones.
1696 * Note also the check for wraparound of 'attr_gencount'
1697 *
1698 * The function returns '1' if it thinks the attributes in @fattr are
1699 * more recent than the ones cached in @inode. Otherwise it returns
1700 * the value '0'.
1701 */
nfs_inode_attrs_cmp_generic(const struct nfs_fattr * fattr,const struct inode * inode)1702 static int nfs_inode_attrs_cmp_generic(const struct nfs_fattr *fattr,
1703 const struct inode *inode)
1704 {
1705 unsigned long attr_gencount = NFS_I(inode)->attr_gencount;
1706
1707 return (long)(fattr->gencount - attr_gencount) > 0 ||
1708 (long)(attr_gencount - nfs_read_attr_generation_counter()) > 0;
1709 }
1710
1711 /**
1712 * nfs_inode_attrs_cmp_monotonic - compare attributes
1713 * @fattr: attributes
1714 * @inode: pointer to inode
1715 *
1716 * Attempt to divine whether or not an RPC call reply carrying stale
1717 * attributes got scheduled after another call carrying updated ones.
1718 *
1719 * We assume that the server observes monotonic semantics for
1720 * the change attribute, so a larger value means that the attributes in
1721 * @fattr are more recent, in which case the function returns the
1722 * value '1'.
1723 * A return value of '0' indicates no measurable change
1724 * A return value of '-1' means that the attributes in @inode are
1725 * more recent.
1726 */
nfs_inode_attrs_cmp_monotonic(const struct nfs_fattr * fattr,const struct inode * inode)1727 static int nfs_inode_attrs_cmp_monotonic(const struct nfs_fattr *fattr,
1728 const struct inode *inode)
1729 {
1730 s64 diff = fattr->change_attr - inode_peek_iversion_raw(inode);
1731 if (diff > 0)
1732 return 1;
1733 return diff == 0 ? 0 : -1;
1734 }
1735
1736 /**
1737 * nfs_inode_attrs_cmp_strict_monotonic - compare attributes
1738 * @fattr: attributes
1739 * @inode: pointer to inode
1740 *
1741 * Attempt to divine whether or not an RPC call reply carrying stale
1742 * attributes got scheduled after another call carrying updated ones.
1743 *
1744 * We assume that the server observes strictly monotonic semantics for
1745 * the change attribute, so a larger value means that the attributes in
1746 * @fattr are more recent, in which case the function returns the
1747 * value '1'.
1748 * A return value of '-1' means that the attributes in @inode are
1749 * more recent or unchanged.
1750 */
nfs_inode_attrs_cmp_strict_monotonic(const struct nfs_fattr * fattr,const struct inode * inode)1751 static int nfs_inode_attrs_cmp_strict_monotonic(const struct nfs_fattr *fattr,
1752 const struct inode *inode)
1753 {
1754 return nfs_inode_attrs_cmp_monotonic(fattr, inode) > 0 ? 1 : -1;
1755 }
1756
1757 /**
1758 * nfs_inode_attrs_cmp - compare attributes
1759 * @fattr: attributes
1760 * @inode: pointer to inode
1761 *
1762 * This function returns '1' if it thinks the attributes in @fattr are
1763 * more recent than the ones cached in @inode. It returns '-1' if
1764 * the attributes in @inode are more recent than the ones in @fattr,
1765 * and it returns 0 if not sure.
1766 */
nfs_inode_attrs_cmp(const struct nfs_fattr * fattr,const struct inode * inode)1767 static int nfs_inode_attrs_cmp(const struct nfs_fattr *fattr,
1768 const struct inode *inode)
1769 {
1770 if (nfs_inode_attrs_cmp_generic(fattr, inode) > 0)
1771 return 1;
1772 switch (NFS_SERVER(inode)->change_attr_type) {
1773 case NFS4_CHANGE_TYPE_IS_UNDEFINED:
1774 break;
1775 case NFS4_CHANGE_TYPE_IS_TIME_METADATA:
1776 if (!(fattr->valid & NFS_ATTR_FATTR_CHANGE))
1777 break;
1778 return nfs_inode_attrs_cmp_monotonic(fattr, inode);
1779 default:
1780 if (!(fattr->valid & NFS_ATTR_FATTR_CHANGE))
1781 break;
1782 return nfs_inode_attrs_cmp_strict_monotonic(fattr, inode);
1783 }
1784 return 0;
1785 }
1786
1787 /**
1788 * nfs_inode_finish_partial_attr_update - complete a previous inode update
1789 * @fattr: attributes
1790 * @inode: pointer to inode
1791 *
1792 * Returns '1' if the last attribute update left the inode cached
1793 * attributes in a partially unrevalidated state, and @fattr
1794 * matches the change attribute of that partial update.
1795 * Otherwise returns '0'.
1796 */
nfs_inode_finish_partial_attr_update(const struct nfs_fattr * fattr,const struct inode * inode)1797 static int nfs_inode_finish_partial_attr_update(const struct nfs_fattr *fattr,
1798 const struct inode *inode)
1799 {
1800 const unsigned long check_valid =
1801 NFS_INO_INVALID_ATIME | NFS_INO_INVALID_CTIME |
1802 NFS_INO_INVALID_MTIME | NFS_INO_INVALID_SIZE |
1803 NFS_INO_INVALID_BLOCKS | NFS_INO_INVALID_OTHER |
1804 NFS_INO_INVALID_NLINK;
1805 unsigned long cache_validity = NFS_I(inode)->cache_validity;
1806 enum nfs4_change_attr_type ctype = NFS_SERVER(inode)->change_attr_type;
1807
1808 if (ctype != NFS4_CHANGE_TYPE_IS_UNDEFINED &&
1809 !(cache_validity & NFS_INO_INVALID_CHANGE) &&
1810 (cache_validity & check_valid) != 0 &&
1811 (fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
1812 nfs_inode_attrs_cmp_monotonic(fattr, inode) == 0)
1813 return 1;
1814 return 0;
1815 }
1816
nfs_refresh_inode_locked(struct inode * inode,struct nfs_fattr * fattr)1817 static int nfs_refresh_inode_locked(struct inode *inode,
1818 struct nfs_fattr *fattr)
1819 {
1820 int attr_cmp = nfs_inode_attrs_cmp(fattr, inode);
1821 int ret = 0;
1822
1823 trace_nfs_refresh_inode_enter(inode);
1824
1825 if (attr_cmp > 0 || nfs_inode_finish_partial_attr_update(fattr, inode))
1826 ret = nfs_update_inode(inode, fattr);
1827 else if (attr_cmp == 0)
1828 ret = nfs_check_inode_attributes(inode, fattr);
1829
1830 trace_nfs_refresh_inode_exit(inode, ret);
1831 return ret;
1832 }
1833
1834 /**
1835 * nfs_refresh_inode - try to update the inode attribute cache
1836 * @inode: pointer to inode
1837 * @fattr: updated attributes
1838 *
1839 * Check that an RPC call that returned attributes has not overlapped with
1840 * other recent updates of the inode metadata, then decide whether it is
1841 * safe to do a full update of the inode attributes, or whether just to
1842 * call nfs_check_inode_attributes.
1843 */
nfs_refresh_inode(struct inode * inode,struct nfs_fattr * fattr)1844 int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
1845 {
1846 int status;
1847
1848 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1849 return 0;
1850 spin_lock(&inode->i_lock);
1851 status = nfs_refresh_inode_locked(inode, fattr);
1852 spin_unlock(&inode->i_lock);
1853
1854 return status;
1855 }
1856 EXPORT_SYMBOL_GPL(nfs_refresh_inode);
1857
nfs_post_op_update_inode_locked(struct inode * inode,struct nfs_fattr * fattr,unsigned int invalid)1858 static int nfs_post_op_update_inode_locked(struct inode *inode,
1859 struct nfs_fattr *fattr, unsigned int invalid)
1860 {
1861 if (S_ISDIR(inode->i_mode))
1862 invalid |= NFS_INO_INVALID_DATA;
1863 nfs_set_cache_invalid(inode, invalid);
1864 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
1865 return 0;
1866 return nfs_refresh_inode_locked(inode, fattr);
1867 }
1868
1869 /**
1870 * nfs_post_op_update_inode - try to update the inode attribute cache
1871 * @inode: pointer to inode
1872 * @fattr: updated attributes
1873 *
1874 * After an operation that has changed the inode metadata, mark the
1875 * attribute cache as being invalid, then try to update it.
1876 *
1877 * NB: if the server didn't return any post op attributes, this
1878 * function will force the retrieval of attributes before the next
1879 * NFS request. Thus it should be used only for operations that
1880 * are expected to change one or more attributes, to avoid
1881 * unnecessary NFS requests and trips through nfs_update_inode().
1882 */
nfs_post_op_update_inode(struct inode * inode,struct nfs_fattr * fattr)1883 int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1884 {
1885 int status;
1886
1887 spin_lock(&inode->i_lock);
1888 nfs_fattr_set_barrier(fattr);
1889 status = nfs_post_op_update_inode_locked(inode, fattr,
1890 NFS_INO_INVALID_CHANGE
1891 | NFS_INO_INVALID_CTIME
1892 | NFS_INO_REVAL_FORCED);
1893 spin_unlock(&inode->i_lock);
1894
1895 return status;
1896 }
1897 EXPORT_SYMBOL_GPL(nfs_post_op_update_inode);
1898
1899 /**
1900 * nfs_post_op_update_inode_force_wcc_locked - update the inode attribute cache
1901 * @inode: pointer to inode
1902 * @fattr: updated attributes
1903 *
1904 * After an operation that has changed the inode metadata, mark the
1905 * attribute cache as being invalid, then try to update it. Fake up
1906 * weak cache consistency data, if none exist.
1907 *
1908 * This function is mainly designed to be used by the ->write_done() functions.
1909 */
nfs_post_op_update_inode_force_wcc_locked(struct inode * inode,struct nfs_fattr * fattr)1910 int nfs_post_op_update_inode_force_wcc_locked(struct inode *inode, struct nfs_fattr *fattr)
1911 {
1912 int attr_cmp = nfs_inode_attrs_cmp(fattr, inode);
1913 int status;
1914
1915 /* Don't do a WCC update if these attributes are already stale */
1916 if (attr_cmp < 0)
1917 return 0;
1918 if ((fattr->valid & NFS_ATTR_FATTR) == 0 || !attr_cmp) {
1919 fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE
1920 | NFS_ATTR_FATTR_PRESIZE
1921 | NFS_ATTR_FATTR_PREMTIME
1922 | NFS_ATTR_FATTR_PRECTIME);
1923 goto out_noforce;
1924 }
1925 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
1926 (fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) {
1927 fattr->pre_change_attr = inode_peek_iversion_raw(inode);
1928 fattr->valid |= NFS_ATTR_FATTR_PRECHANGE;
1929 }
1930 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 &&
1931 (fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) {
1932 fattr->pre_ctime = inode->i_ctime;
1933 fattr->valid |= NFS_ATTR_FATTR_PRECTIME;
1934 }
1935 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 &&
1936 (fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) {
1937 fattr->pre_mtime = inode->i_mtime;
1938 fattr->valid |= NFS_ATTR_FATTR_PREMTIME;
1939 }
1940 if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 &&
1941 (fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) {
1942 fattr->pre_size = i_size_read(inode);
1943 fattr->valid |= NFS_ATTR_FATTR_PRESIZE;
1944 }
1945 out_noforce:
1946 status = nfs_post_op_update_inode_locked(inode, fattr,
1947 NFS_INO_INVALID_CHANGE
1948 | NFS_INO_INVALID_CTIME
1949 | NFS_INO_INVALID_MTIME
1950 | NFS_INO_INVALID_BLOCKS);
1951 return status;
1952 }
1953
1954 /**
1955 * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache
1956 * @inode: pointer to inode
1957 * @fattr: updated attributes
1958 *
1959 * After an operation that has changed the inode metadata, mark the
1960 * attribute cache as being invalid, then try to update it. Fake up
1961 * weak cache consistency data, if none exist.
1962 *
1963 * This function is mainly designed to be used by the ->write_done() functions.
1964 */
nfs_post_op_update_inode_force_wcc(struct inode * inode,struct nfs_fattr * fattr)1965 int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr)
1966 {
1967 int status;
1968
1969 spin_lock(&inode->i_lock);
1970 nfs_fattr_set_barrier(fattr);
1971 status = nfs_post_op_update_inode_force_wcc_locked(inode, fattr);
1972 spin_unlock(&inode->i_lock);
1973 return status;
1974 }
1975 EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc);
1976
1977
1978 /*
1979 * Many nfs protocol calls return the new file attributes after
1980 * an operation. Here we update the inode to reflect the state
1981 * of the server's inode.
1982 *
1983 * This is a bit tricky because we have to make sure all dirty pages
1984 * have been sent off to the server before calling invalidate_inode_pages.
1985 * To make sure no other process adds more write requests while we try
1986 * our best to flush them, we make them sleep during the attribute refresh.
1987 *
1988 * A very similar scenario holds for the dir cache.
1989 */
nfs_update_inode(struct inode * inode,struct nfs_fattr * fattr)1990 static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1991 {
1992 struct nfs_server *server = NFS_SERVER(inode);
1993 struct nfs_inode *nfsi = NFS_I(inode);
1994 loff_t cur_isize, new_isize;
1995 u64 fattr_supported = server->fattr_valid;
1996 unsigned long invalid = 0;
1997 unsigned long now = jiffies;
1998 unsigned long save_cache_validity;
1999 bool have_writers = nfs_file_has_buffered_writers(nfsi);
2000 bool cache_revalidated = true;
2001 bool attr_changed = false;
2002 bool have_delegation;
2003
2004 dfprintk(VFS, "NFS: %s(%s/%lu fh_crc=0x%08x ct=%d info=0x%x)\n",
2005 __func__, inode->i_sb->s_id, inode->i_ino,
2006 nfs_display_fhandle_hash(NFS_FH(inode)),
2007 atomic_read(&inode->i_count), fattr->valid);
2008
2009 if (!(fattr->valid & NFS_ATTR_FATTR_FILEID)) {
2010 /* Only a mounted-on-fileid? Just exit */
2011 if (fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
2012 return 0;
2013 /* Has the inode gone and changed behind our back? */
2014 } else if (nfsi->fileid != fattr->fileid) {
2015 /* Is this perhaps the mounted-on fileid? */
2016 if ((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) &&
2017 nfsi->fileid == fattr->mounted_on_fileid)
2018 return 0;
2019 printk(KERN_ERR "NFS: server %s error: fileid changed\n"
2020 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
2021 NFS_SERVER(inode)->nfs_client->cl_hostname,
2022 inode->i_sb->s_id, (long long)nfsi->fileid,
2023 (long long)fattr->fileid);
2024 goto out_err;
2025 }
2026
2027 /*
2028 * Make sure the inode's type hasn't changed.
2029 */
2030 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && inode_wrong_type(inode, fattr->mode)) {
2031 /*
2032 * Big trouble! The inode has become a different object.
2033 */
2034 printk(KERN_DEBUG "NFS: %s: inode %lu mode changed, %07o to %07o\n",
2035 __func__, inode->i_ino, inode->i_mode, fattr->mode);
2036 goto out_err;
2037 }
2038
2039 /* Update the fsid? */
2040 if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) &&
2041 !nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
2042 !IS_AUTOMOUNT(inode))
2043 server->fsid = fattr->fsid;
2044
2045 /* Save the delegation state before clearing cache_validity */
2046 have_delegation = nfs_have_delegated_attributes(inode);
2047
2048 /*
2049 * Update the read time so we don't revalidate too often.
2050 */
2051 nfsi->read_cache_jiffies = fattr->time_start;
2052
2053 save_cache_validity = nfsi->cache_validity;
2054 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR
2055 | NFS_INO_INVALID_ATIME
2056 | NFS_INO_REVAL_FORCED
2057 | NFS_INO_INVALID_BLOCKS);
2058
2059 /* Do atomic weak cache consistency updates */
2060 nfs_wcc_update_inode(inode, fattr);
2061
2062 if (pnfs_layoutcommit_outstanding(inode)) {
2063 nfsi->cache_validity |=
2064 save_cache_validity &
2065 (NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_CTIME |
2066 NFS_INO_INVALID_MTIME | NFS_INO_INVALID_SIZE |
2067 NFS_INO_INVALID_BLOCKS);
2068 cache_revalidated = false;
2069 }
2070
2071 /* More cache consistency checks */
2072 if (fattr->valid & NFS_ATTR_FATTR_CHANGE) {
2073 if (!inode_eq_iversion_raw(inode, fattr->change_attr)) {
2074 /* Could it be a race with writeback? */
2075 if (!(have_writers || have_delegation)) {
2076 invalid |= NFS_INO_INVALID_DATA
2077 | NFS_INO_INVALID_ACCESS
2078 | NFS_INO_INVALID_ACL
2079 | NFS_INO_INVALID_XATTR;
2080 /* Force revalidate of all attributes */
2081 save_cache_validity |= NFS_INO_INVALID_CTIME
2082 | NFS_INO_INVALID_MTIME
2083 | NFS_INO_INVALID_SIZE
2084 | NFS_INO_INVALID_BLOCKS
2085 | NFS_INO_INVALID_NLINK
2086 | NFS_INO_INVALID_MODE
2087 | NFS_INO_INVALID_OTHER;
2088 if (S_ISDIR(inode->i_mode))
2089 nfs_force_lookup_revalidate(inode);
2090 attr_changed = true;
2091 dprintk("NFS: change_attr change on server for file %s/%ld\n",
2092 inode->i_sb->s_id,
2093 inode->i_ino);
2094 } else if (!have_delegation)
2095 nfsi->cache_validity |= NFS_INO_DATA_INVAL_DEFER;
2096 inode_set_iversion_raw(inode, fattr->change_attr);
2097 }
2098 } else {
2099 nfsi->cache_validity |=
2100 save_cache_validity & NFS_INO_INVALID_CHANGE;
2101 if (!have_delegation ||
2102 (nfsi->cache_validity & NFS_INO_INVALID_CHANGE) != 0)
2103 cache_revalidated = false;
2104 }
2105
2106 if (fattr->valid & NFS_ATTR_FATTR_MTIME)
2107 inode->i_mtime = fattr->mtime;
2108 else if (fattr_supported & NFS_ATTR_FATTR_MTIME)
2109 nfsi->cache_validity |=
2110 save_cache_validity & NFS_INO_INVALID_MTIME;
2111
2112 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
2113 inode->i_ctime = fattr->ctime;
2114 else if (fattr_supported & NFS_ATTR_FATTR_CTIME)
2115 nfsi->cache_validity |=
2116 save_cache_validity & NFS_INO_INVALID_CTIME;
2117
2118 /* Check if our cached file size is stale */
2119 if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
2120 new_isize = nfs_size_to_loff_t(fattr->size);
2121 cur_isize = i_size_read(inode);
2122 if (new_isize != cur_isize && !have_delegation) {
2123 /* Do we perhaps have any outstanding writes, or has
2124 * the file grown beyond our last write? */
2125 if (!nfs_have_writebacks(inode) || new_isize > cur_isize) {
2126 trace_nfs_size_update(inode, new_isize);
2127 i_size_write(inode, new_isize);
2128 if (!have_writers)
2129 invalid |= NFS_INO_INVALID_DATA;
2130 }
2131 }
2132 if (new_isize == 0 &&
2133 !(fattr->valid & (NFS_ATTR_FATTR_SPACE_USED |
2134 NFS_ATTR_FATTR_BLOCKS_USED))) {
2135 fattr->du.nfs3.used = 0;
2136 fattr->valid |= NFS_ATTR_FATTR_SPACE_USED;
2137 }
2138 } else
2139 nfsi->cache_validity |=
2140 save_cache_validity & NFS_INO_INVALID_SIZE;
2141
2142 if (fattr->valid & NFS_ATTR_FATTR_ATIME)
2143 inode->i_atime = fattr->atime;
2144 else if (fattr_supported & NFS_ATTR_FATTR_ATIME)
2145 nfsi->cache_validity |=
2146 save_cache_validity & NFS_INO_INVALID_ATIME;
2147
2148 if (fattr->valid & NFS_ATTR_FATTR_MODE) {
2149 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
2150 umode_t newmode = inode->i_mode & S_IFMT;
2151 newmode |= fattr->mode & S_IALLUGO;
2152 inode->i_mode = newmode;
2153 invalid |= NFS_INO_INVALID_ACCESS
2154 | NFS_INO_INVALID_ACL;
2155 }
2156 } else if (fattr_supported & NFS_ATTR_FATTR_MODE)
2157 nfsi->cache_validity |=
2158 save_cache_validity & NFS_INO_INVALID_MODE;
2159
2160 if (fattr->valid & NFS_ATTR_FATTR_OWNER) {
2161 if (!uid_eq(inode->i_uid, fattr->uid)) {
2162 invalid |= NFS_INO_INVALID_ACCESS
2163 | NFS_INO_INVALID_ACL;
2164 inode->i_uid = fattr->uid;
2165 }
2166 } else if (fattr_supported & NFS_ATTR_FATTR_OWNER)
2167 nfsi->cache_validity |=
2168 save_cache_validity & NFS_INO_INVALID_OTHER;
2169
2170 if (fattr->valid & NFS_ATTR_FATTR_GROUP) {
2171 if (!gid_eq(inode->i_gid, fattr->gid)) {
2172 invalid |= NFS_INO_INVALID_ACCESS
2173 | NFS_INO_INVALID_ACL;
2174 inode->i_gid = fattr->gid;
2175 }
2176 } else if (fattr_supported & NFS_ATTR_FATTR_GROUP)
2177 nfsi->cache_validity |=
2178 save_cache_validity & NFS_INO_INVALID_OTHER;
2179
2180 if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
2181 if (inode->i_nlink != fattr->nlink)
2182 set_nlink(inode, fattr->nlink);
2183 } else if (fattr_supported & NFS_ATTR_FATTR_NLINK)
2184 nfsi->cache_validity |=
2185 save_cache_validity & NFS_INO_INVALID_NLINK;
2186
2187 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
2188 /*
2189 * report the blocks in 512byte units
2190 */
2191 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
2192 } else if (fattr_supported & NFS_ATTR_FATTR_SPACE_USED)
2193 nfsi->cache_validity |=
2194 save_cache_validity & NFS_INO_INVALID_BLOCKS;
2195
2196 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
2197 inode->i_blocks = fattr->du.nfs2.blocks;
2198 else if (fattr_supported & NFS_ATTR_FATTR_BLOCKS_USED)
2199 nfsi->cache_validity |=
2200 save_cache_validity & NFS_INO_INVALID_BLOCKS;
2201
2202 /* Update attrtimeo value if we're out of the unstable period */
2203 if (attr_changed) {
2204 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
2205 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
2206 nfsi->attrtimeo_timestamp = now;
2207 /* Set barrier to be more recent than all outstanding updates */
2208 nfsi->attr_gencount = nfs_inc_attr_generation_counter();
2209 } else {
2210 if (cache_revalidated) {
2211 if (!time_in_range_open(now, nfsi->attrtimeo_timestamp,
2212 nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
2213 nfsi->attrtimeo <<= 1;
2214 if (nfsi->attrtimeo > NFS_MAXATTRTIMEO(inode))
2215 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
2216 }
2217 nfsi->attrtimeo_timestamp = now;
2218 }
2219 /* Set the barrier to be more recent than this fattr */
2220 if ((long)(fattr->gencount - nfsi->attr_gencount) > 0)
2221 nfsi->attr_gencount = fattr->gencount;
2222 }
2223
2224 /* Don't invalidate the data if we were to blame */
2225 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
2226 || S_ISLNK(inode->i_mode)))
2227 invalid &= ~NFS_INO_INVALID_DATA;
2228 nfs_set_cache_invalid(inode, invalid);
2229
2230 return 0;
2231 out_err:
2232 /*
2233 * No need to worry about unhashing the dentry, as the
2234 * lookup validation will know that the inode is bad.
2235 * (But we fall through to invalidate the caches.)
2236 */
2237 nfs_set_inode_stale_locked(inode);
2238 return -ESTALE;
2239 }
2240
nfs_alloc_inode(struct super_block * sb)2241 struct inode *nfs_alloc_inode(struct super_block *sb)
2242 {
2243 struct nfs_inode *nfsi;
2244 nfsi = kmem_cache_alloc(nfs_inode_cachep, GFP_KERNEL);
2245 if (!nfsi)
2246 return NULL;
2247 nfsi->flags = 0UL;
2248 nfsi->cache_validity = 0UL;
2249 #if IS_ENABLED(CONFIG_NFS_V4)
2250 nfsi->nfs4_acl = NULL;
2251 #endif /* CONFIG_NFS_V4 */
2252 #ifdef CONFIG_NFS_V4_2
2253 nfsi->xattr_cache = NULL;
2254 #endif
2255 return &nfsi->vfs_inode;
2256 }
2257 EXPORT_SYMBOL_GPL(nfs_alloc_inode);
2258
nfs_free_inode(struct inode * inode)2259 void nfs_free_inode(struct inode *inode)
2260 {
2261 kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
2262 }
2263 EXPORT_SYMBOL_GPL(nfs_free_inode);
2264
nfs4_init_once(struct nfs_inode * nfsi)2265 static inline void nfs4_init_once(struct nfs_inode *nfsi)
2266 {
2267 #if IS_ENABLED(CONFIG_NFS_V4)
2268 INIT_LIST_HEAD(&nfsi->open_states);
2269 nfsi->delegation = NULL;
2270 init_rwsem(&nfsi->rwsem);
2271 nfsi->layout = NULL;
2272 #endif
2273 }
2274
init_once(void * foo)2275 static void init_once(void *foo)
2276 {
2277 struct nfs_inode *nfsi = (struct nfs_inode *) foo;
2278
2279 inode_init_once(&nfsi->vfs_inode);
2280 INIT_LIST_HEAD(&nfsi->open_files);
2281 INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
2282 INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
2283 nfs4_init_once(nfsi);
2284 }
2285
nfs_init_inodecache(void)2286 static int __init nfs_init_inodecache(void)
2287 {
2288 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
2289 sizeof(struct nfs_inode),
2290 0, (SLAB_RECLAIM_ACCOUNT|
2291 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
2292 init_once);
2293 if (nfs_inode_cachep == NULL)
2294 return -ENOMEM;
2295
2296 return 0;
2297 }
2298
nfs_destroy_inodecache(void)2299 static void nfs_destroy_inodecache(void)
2300 {
2301 /*
2302 * Make sure all delayed rcu free inodes are flushed before we
2303 * destroy cache.
2304 */
2305 rcu_barrier();
2306 kmem_cache_destroy(nfs_inode_cachep);
2307 }
2308
2309 struct workqueue_struct *nfsiod_workqueue;
2310 EXPORT_SYMBOL_GPL(nfsiod_workqueue);
2311
2312 /*
2313 * start up the nfsiod workqueue
2314 */
nfsiod_start(void)2315 static int nfsiod_start(void)
2316 {
2317 struct workqueue_struct *wq;
2318 dprintk("RPC: creating workqueue nfsiod\n");
2319 wq = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM | WQ_UNBOUND, 0);
2320 if (wq == NULL)
2321 return -ENOMEM;
2322 nfsiod_workqueue = wq;
2323 return 0;
2324 }
2325
2326 /*
2327 * Destroy the nfsiod workqueue
2328 */
nfsiod_stop(void)2329 static void nfsiod_stop(void)
2330 {
2331 struct workqueue_struct *wq;
2332
2333 wq = nfsiod_workqueue;
2334 if (wq == NULL)
2335 return;
2336 nfsiod_workqueue = NULL;
2337 destroy_workqueue(wq);
2338 }
2339
2340 unsigned int nfs_net_id;
2341 EXPORT_SYMBOL_GPL(nfs_net_id);
2342
nfs_net_init(struct net * net)2343 static int nfs_net_init(struct net *net)
2344 {
2345 nfs_clients_init(net);
2346 return nfs_fs_proc_net_init(net);
2347 }
2348
nfs_net_exit(struct net * net)2349 static void nfs_net_exit(struct net *net)
2350 {
2351 nfs_fs_proc_net_exit(net);
2352 nfs_clients_exit(net);
2353 }
2354
2355 static struct pernet_operations nfs_net_ops = {
2356 .init = nfs_net_init,
2357 .exit = nfs_net_exit,
2358 .id = &nfs_net_id,
2359 .size = sizeof(struct nfs_net),
2360 };
2361
2362 /*
2363 * Initialize NFS
2364 */
init_nfs_fs(void)2365 static int __init init_nfs_fs(void)
2366 {
2367 int err;
2368
2369 err = nfs_sysfs_init();
2370 if (err < 0)
2371 goto out10;
2372
2373 err = register_pernet_subsys(&nfs_net_ops);
2374 if (err < 0)
2375 goto out9;
2376
2377 err = nfs_fscache_register();
2378 if (err < 0)
2379 goto out8;
2380
2381 err = nfsiod_start();
2382 if (err)
2383 goto out7;
2384
2385 err = nfs_fs_proc_init();
2386 if (err)
2387 goto out6;
2388
2389 err = nfs_init_nfspagecache();
2390 if (err)
2391 goto out5;
2392
2393 err = nfs_init_inodecache();
2394 if (err)
2395 goto out4;
2396
2397 err = nfs_init_readpagecache();
2398 if (err)
2399 goto out3;
2400
2401 err = nfs_init_writepagecache();
2402 if (err)
2403 goto out2;
2404
2405 err = nfs_init_directcache();
2406 if (err)
2407 goto out1;
2408
2409 rpc_proc_register(&init_net, &nfs_rpcstat);
2410
2411 err = register_nfs_fs();
2412 if (err)
2413 goto out0;
2414
2415 return 0;
2416 out0:
2417 rpc_proc_unregister(&init_net, "nfs");
2418 nfs_destroy_directcache();
2419 out1:
2420 nfs_destroy_writepagecache();
2421 out2:
2422 nfs_destroy_readpagecache();
2423 out3:
2424 nfs_destroy_inodecache();
2425 out4:
2426 nfs_destroy_nfspagecache();
2427 out5:
2428 nfs_fs_proc_exit();
2429 out6:
2430 nfsiod_stop();
2431 out7:
2432 nfs_fscache_unregister();
2433 out8:
2434 unregister_pernet_subsys(&nfs_net_ops);
2435 out9:
2436 nfs_sysfs_exit();
2437 out10:
2438 return err;
2439 }
2440
exit_nfs_fs(void)2441 static void __exit exit_nfs_fs(void)
2442 {
2443 nfs_destroy_directcache();
2444 nfs_destroy_writepagecache();
2445 nfs_destroy_readpagecache();
2446 nfs_destroy_inodecache();
2447 nfs_destroy_nfspagecache();
2448 nfs_fscache_unregister();
2449 unregister_pernet_subsys(&nfs_net_ops);
2450 rpc_proc_unregister(&init_net, "nfs");
2451 unregister_nfs_fs();
2452 nfs_fs_proc_exit();
2453 nfsiod_stop();
2454 nfs_sysfs_exit();
2455 }
2456
2457 /* Not quite true; I just maintain it */
2458 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
2459 MODULE_LICENSE("GPL");
2460 module_param(enable_ino64, bool, 0644);
2461
2462 module_init(init_nfs_fs)
2463 module_exit(exit_nfs_fs)
2464