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_bit_killable(struct wait_bit_key * key,int mode)75 int nfs_wait_bit_killable(struct wait_bit_key *key, int mode)
76 {
77 if (unlikely(nfs_current_task_exiting()))
78 return -EINTR;
79 schedule();
80 if (signal_pending_state(mode, current))
81 return -ERESTARTSYS;
82 return 0;
83 }
84 EXPORT_SYMBOL_GPL(nfs_wait_bit_killable);
85
86 /**
87 * nfs_compat_user_ino64 - returns the user-visible inode number
88 * @fileid: 64-bit fileid
89 *
90 * This function returns a 32-bit inode number if the boot parameter
91 * nfs.enable_ino64 is zero.
92 */
nfs_compat_user_ino64(u64 fileid)93 u64 nfs_compat_user_ino64(u64 fileid)
94 {
95 #ifdef CONFIG_COMPAT
96 compat_ulong_t ino;
97 #else
98 unsigned long ino;
99 #endif
100
101 if (enable_ino64)
102 return fileid;
103 ino = fileid;
104 if (sizeof(ino) < sizeof(fileid))
105 ino ^= fileid >> (sizeof(fileid)-sizeof(ino)) * 8;
106 return ino;
107 }
108
nfs_drop_inode(struct inode * inode)109 int nfs_drop_inode(struct inode *inode)
110 {
111 return NFS_STALE(inode) || inode_generic_drop(inode);
112 }
113 EXPORT_SYMBOL_GPL(nfs_drop_inode);
114
nfs_clear_inode(struct inode * inode)115 void nfs_clear_inode(struct inode *inode)
116 {
117 /*
118 * The following should never happen...
119 */
120 WARN_ON_ONCE(nfs_have_writebacks(inode));
121 WARN_ON_ONCE(!list_empty(&NFS_I(inode)->open_files));
122 nfs_zap_acl_cache(inode);
123 nfs_access_zap_cache(inode);
124 nfs_fscache_clear_inode(inode);
125 }
126 EXPORT_SYMBOL_GPL(nfs_clear_inode);
127
nfs_evict_inode(struct inode * inode)128 void nfs_evict_inode(struct inode *inode)
129 {
130 truncate_inode_pages_final(&inode->i_data);
131 clear_inode(inode);
132 nfs_clear_inode(inode);
133 }
134
nfs_sync_inode(struct inode * inode)135 int nfs_sync_inode(struct inode *inode)
136 {
137 inode_dio_wait(inode);
138 return nfs_wb_all(inode);
139 }
140 EXPORT_SYMBOL_GPL(nfs_sync_inode);
141
142 /**
143 * nfs_sync_mapping - helper to flush all mmapped dirty data to disk
144 * @mapping: pointer to struct address_space
145 */
nfs_sync_mapping(struct address_space * mapping)146 int nfs_sync_mapping(struct address_space *mapping)
147 {
148 int ret = 0;
149
150 if (mapping->nrpages != 0) {
151 unmap_mapping_range(mapping, 0, 0, 0);
152 ret = nfs_wb_all(mapping->host);
153 }
154 return ret;
155 }
156
nfs_attribute_timeout(struct inode * inode)157 static int nfs_attribute_timeout(struct inode *inode)
158 {
159 struct nfs_inode *nfsi = NFS_I(inode);
160
161 return !time_in_range_open(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo);
162 }
163
nfs_check_cache_flags_invalid(struct inode * inode,unsigned long flags)164 static bool nfs_check_cache_flags_invalid(struct inode *inode,
165 unsigned long flags)
166 {
167 unsigned long cache_validity = READ_ONCE(NFS_I(inode)->cache_validity);
168
169 return (cache_validity & flags) != 0;
170 }
171
nfs_check_cache_invalid(struct inode * inode,unsigned long flags)172 bool nfs_check_cache_invalid(struct inode *inode, unsigned long flags)
173 {
174 if (nfs_check_cache_flags_invalid(inode, flags))
175 return true;
176 return nfs_attribute_cache_expired(inode);
177 }
178 EXPORT_SYMBOL_GPL(nfs_check_cache_invalid);
179
180 #ifdef CONFIG_NFS_V4_2
nfs_has_xattr_cache(const struct nfs_inode * nfsi)181 static bool nfs_has_xattr_cache(const struct nfs_inode *nfsi)
182 {
183 return nfsi->xattr_cache != NULL;
184 }
185 #else
nfs_has_xattr_cache(const struct nfs_inode * nfsi)186 static bool nfs_has_xattr_cache(const struct nfs_inode *nfsi)
187 {
188 return false;
189 }
190 #endif
191
nfs_set_cache_invalid(struct inode * inode,unsigned long flags)192 void nfs_set_cache_invalid(struct inode *inode, unsigned long flags)
193 {
194 struct nfs_inode *nfsi = NFS_I(inode);
195
196 if (nfs_have_delegated_attributes(inode)) {
197 if (!(flags & NFS_INO_REVAL_FORCED))
198 flags &= ~(NFS_INO_INVALID_MODE |
199 NFS_INO_INVALID_OTHER |
200 NFS_INO_INVALID_BTIME |
201 NFS_INO_INVALID_XATTR);
202 flags &= ~(NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_SIZE);
203 }
204
205 if (!nfs_has_xattr_cache(nfsi))
206 flags &= ~NFS_INO_INVALID_XATTR;
207 if (flags & NFS_INO_INVALID_DATA)
208 nfs_fscache_invalidate(inode, 0);
209 flags &= ~NFS_INO_REVAL_FORCED;
210
211 flags |= nfsi->cache_validity;
212 if (inode->i_mapping->nrpages == 0)
213 flags &= ~NFS_INO_INVALID_DATA;
214
215 /* pairs with nfs_clear_invalid_mapping()'s smp_load_acquire() */
216 smp_store_release(&nfsi->cache_validity, flags);
217
218 if (inode->i_mapping->nrpages == 0 ||
219 nfsi->cache_validity & NFS_INO_INVALID_DATA) {
220 nfs_ooo_clear(nfsi);
221 }
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 else
246 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR |
247 NFS_INO_INVALID_ACCESS |
248 NFS_INO_INVALID_ACL |
249 NFS_INO_INVALID_XATTR);
250 nfs_zap_label_cache_locked(nfsi);
251 }
252
nfs_zap_caches(struct inode * inode)253 void nfs_zap_caches(struct inode *inode)
254 {
255 spin_lock(&inode->i_lock);
256 nfs_zap_caches_locked(inode);
257 spin_unlock(&inode->i_lock);
258 }
259
nfs_zap_mapping(struct inode * inode,struct address_space * mapping)260 void nfs_zap_mapping(struct inode *inode, struct address_space *mapping)
261 {
262 if (mapping->nrpages != 0) {
263 spin_lock(&inode->i_lock);
264 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
265 spin_unlock(&inode->i_lock);
266 }
267 }
268
nfs_zap_acl_cache(struct inode * inode)269 void nfs_zap_acl_cache(struct inode *inode)
270 {
271 void (*clear_acl_cache)(struct inode *);
272
273 clear_acl_cache = NFS_PROTO(inode)->clear_acl_cache;
274 if (clear_acl_cache != NULL)
275 clear_acl_cache(inode);
276 spin_lock(&inode->i_lock);
277 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_ACL;
278 spin_unlock(&inode->i_lock);
279 }
280 EXPORT_SYMBOL_GPL(nfs_zap_acl_cache);
281
nfs_invalidate_atime(struct inode * inode)282 void nfs_invalidate_atime(struct inode *inode)
283 {
284 if (nfs_have_delegated_atime(inode))
285 return;
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 = 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 = 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 atomic_long_set(&nfsi->redirtied_pages, 0);
433 INIT_LIST_HEAD(&nfsi->commit_info.list);
434 atomic_long_set(&nfsi->commit_info.ncommit, 0);
435 atomic_set(&nfsi->commit_info.rpcs_out, 0);
436 mutex_init(&nfsi->commit_mutex);
437 }
438
nfs_inode_init_dir(struct nfs_inode * nfsi)439 static void nfs_inode_init_dir(struct nfs_inode *nfsi)
440 {
441 nfsi->cache_change_attribute = 0;
442 memset(nfsi->cookieverf, 0, sizeof(nfsi->cookieverf));
443 init_rwsem(&nfsi->rmdir_sem);
444 }
445
446 /*
447 * This is our front-end to iget that looks up inodes by file handle
448 * instead of inode number.
449 */
450 struct inode *
nfs_fhget(struct super_block * sb,struct nfs_fh * fh,struct nfs_fattr * fattr)451 nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
452 {
453 struct nfs_find_desc desc = {
454 .fh = fh,
455 .fattr = fattr
456 };
457 struct inode *inode = ERR_PTR(-ENOENT);
458 u64 fattr_supported = NFS_SB(sb)->fattr_valid;
459 unsigned long hash;
460
461 nfs_attr_check_mountpoint(sb, fattr);
462
463 if (nfs_attr_use_mounted_on_fileid(fattr))
464 fattr->fileid = fattr->mounted_on_fileid;
465 else if ((fattr->valid & NFS_ATTR_FATTR_FILEID) == 0)
466 goto out_no_inode;
467 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) == 0)
468 goto out_no_inode;
469
470 hash = nfs_fattr_to_ino_t(fattr);
471
472 inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
473 if (inode == NULL) {
474 inode = ERR_PTR(-ENOMEM);
475 goto out_no_inode;
476 }
477
478 if (inode_state_read_once(inode) & I_NEW) {
479 struct nfs_inode *nfsi = NFS_I(inode);
480 unsigned long now = jiffies;
481
482 /* We set i_ino for the few things that still rely on it,
483 * such as stat(2) */
484 inode->i_ino = hash;
485
486 /* We can't support update_atime(), since the server will reset it */
487 inode->i_flags |= S_NOATIME|S_NOCMTIME;
488 inode->i_mode = fattr->mode;
489 nfsi->cache_validity = 0;
490 if ((fattr->valid & NFS_ATTR_FATTR_MODE) == 0
491 && (fattr_supported & NFS_ATTR_FATTR_MODE))
492 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MODE);
493 /* Why so? Because we want revalidate for devices/FIFOs, and
494 * that's precisely what we have in nfs_file_inode_operations.
495 */
496 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->file_inode_ops;
497 if (S_ISREG(inode->i_mode)) {
498 inode->i_fop = NFS_SB(sb)->nfs_client->rpc_ops->file_ops;
499 inode->i_data.a_ops = &nfs_file_aops;
500 nfs_inode_init_regular(nfsi);
501 mapping_set_large_folios(inode->i_mapping);
502 } else if (S_ISDIR(inode->i_mode)) {
503 inode->i_op = NFS_SB(sb)->nfs_client->rpc_ops->dir_inode_ops;
504 inode->i_fop = &nfs_dir_operations;
505 inode->i_data.a_ops = &nfs_dir_aops;
506 nfs_inode_init_dir(nfsi);
507 /* Deal with crossing mountpoints */
508 if (fattr->valid & NFS_ATTR_FATTR_MOUNTPOINT ||
509 fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL) {
510 if (fattr->valid & NFS_ATTR_FATTR_V4_REFERRAL)
511 inode->i_op = &nfs_referral_inode_operations;
512 else
513 inode->i_op = &nfs_mountpoint_inode_operations;
514 inode->i_fop = NULL;
515 inode->i_flags |= S_AUTOMOUNT;
516 }
517 } else if (S_ISLNK(inode->i_mode)) {
518 inode->i_op = &nfs_symlink_inode_operations;
519 inode_nohighmem(inode);
520 } else
521 init_special_inode(inode, inode->i_mode, fattr->rdev);
522
523 inode_set_atime(inode, 0, 0);
524 inode_set_mtime(inode, 0, 0);
525 inode_set_ctime(inode, 0, 0);
526 memset(&nfsi->btime, 0, sizeof(nfsi->btime));
527 inode_set_iversion_raw(inode, 0);
528 inode->i_size = 0;
529 clear_nlink(inode);
530 inode->i_uid = make_kuid(&init_user_ns, -2);
531 inode->i_gid = make_kgid(&init_user_ns, -2);
532 inode->i_blocks = 0;
533 nfsi->write_io = 0;
534 nfsi->read_io = 0;
535
536 nfsi->read_cache_jiffies = fattr->time_start;
537 nfsi->attr_gencount = fattr->gencount;
538 if (fattr->valid & NFS_ATTR_FATTR_ATIME)
539 inode_set_atime_to_ts(inode, fattr->atime);
540 else if (fattr_supported & NFS_ATTR_FATTR_ATIME)
541 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
542 if (fattr->valid & NFS_ATTR_FATTR_MTIME)
543 inode_set_mtime_to_ts(inode, fattr->mtime);
544 else if (fattr_supported & NFS_ATTR_FATTR_MTIME)
545 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME);
546 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
547 inode_set_ctime_to_ts(inode, fattr->ctime);
548 else if (fattr_supported & NFS_ATTR_FATTR_CTIME)
549 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CTIME);
550 if (fattr->valid & NFS_ATTR_FATTR_BTIME)
551 nfsi->btime = fattr->btime;
552 else if (fattr_supported & NFS_ATTR_FATTR_BTIME)
553 nfs_set_cache_invalid(inode, NFS_INO_INVALID_BTIME);
554 if (fattr->valid & NFS_ATTR_FATTR_CHANGE)
555 inode_set_iversion_raw(inode, fattr->change_attr);
556 else
557 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE);
558 if (fattr->valid & NFS_ATTR_FATTR_SIZE)
559 inode->i_size = nfs_size_to_loff_t(fattr->size);
560 else
561 nfs_set_cache_invalid(inode, NFS_INO_INVALID_SIZE);
562 if (fattr->valid & NFS_ATTR_FATTR_NLINK)
563 set_nlink(inode, fattr->nlink);
564 else if (fattr_supported & NFS_ATTR_FATTR_NLINK)
565 nfs_set_cache_invalid(inode, NFS_INO_INVALID_NLINK);
566 else
567 set_nlink(inode, 1);
568 if (fattr->valid & NFS_ATTR_FATTR_OWNER)
569 inode->i_uid = fattr->uid;
570 else if (fattr_supported & NFS_ATTR_FATTR_OWNER)
571 nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
572 if (fattr->valid & NFS_ATTR_FATTR_GROUP)
573 inode->i_gid = fattr->gid;
574 else if (fattr_supported & NFS_ATTR_FATTR_GROUP)
575 nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
576 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
577 inode->i_blocks = fattr->du.nfs2.blocks;
578 else if (fattr_supported & NFS_ATTR_FATTR_BLOCKS_USED &&
579 fattr->size != 0)
580 nfs_set_cache_invalid(inode, NFS_INO_INVALID_BLOCKS);
581 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
582 /*
583 * report the blocks in 512byte units
584 */
585 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
586 } else if (fattr_supported & NFS_ATTR_FATTR_SPACE_USED &&
587 fattr->size != 0)
588 nfs_set_cache_invalid(inode, NFS_INO_INVALID_BLOCKS);
589
590 nfs_setsecurity(inode, fattr);
591
592 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
593 nfsi->attrtimeo_timestamp = now;
594 nfsi->access_cache = RB_ROOT;
595
596 nfs_fscache_init_inode(inode);
597
598 unlock_new_inode(inode);
599 } else {
600 int err = nfs_refresh_inode(inode, fattr);
601 if (err < 0) {
602 iput(inode);
603 inode = ERR_PTR(err);
604 goto out_no_inode;
605 }
606 }
607 dprintk("NFS: nfs_fhget(%s/%Lu fh_crc=0x%08x ct=%d)\n",
608 inode->i_sb->s_id,
609 (unsigned long long)NFS_FILEID(inode),
610 nfs_display_fhandle_hash(fh),
611 icount_read(inode));
612
613 out:
614 return inode;
615
616 out_no_inode:
617 dprintk("nfs_fhget: iget failed with error %ld\n", PTR_ERR(inode));
618 goto out;
619 }
620 EXPORT_SYMBOL_GPL(nfs_fhget);
621
622 static void
nfs_fattr_fixup_delegated(struct inode * inode,struct nfs_fattr * fattr)623 nfs_fattr_fixup_delegated(struct inode *inode, struct nfs_fattr *fattr)
624 {
625 unsigned long cache_validity = NFS_I(inode)->cache_validity;
626
627 if (nfs_have_delegated_mtime(inode)) {
628 if (!(cache_validity & NFS_INO_INVALID_CTIME))
629 fattr->valid &= ~(NFS_ATTR_FATTR_PRECTIME |
630 NFS_ATTR_FATTR_CTIME);
631
632 if (!(cache_validity & NFS_INO_INVALID_MTIME))
633 fattr->valid &= ~(NFS_ATTR_FATTR_PREMTIME |
634 NFS_ATTR_FATTR_MTIME);
635
636 if (!(cache_validity & NFS_INO_INVALID_ATIME))
637 fattr->valid &= ~NFS_ATTR_FATTR_ATIME;
638 } else if (nfs_have_delegated_atime(inode)) {
639 if (!(cache_validity & NFS_INO_INVALID_ATIME))
640 fattr->valid &= ~NFS_ATTR_FATTR_ATIME;
641 }
642 }
643
nfs_set_timestamps_to_ts(struct inode * inode,struct iattr * attr)644 static void nfs_set_timestamps_to_ts(struct inode *inode, struct iattr *attr)
645 {
646 unsigned int cache_flags = 0;
647
648 if (attr->ia_valid & ATTR_MTIME_SET) {
649 struct timespec64 ctime = inode_get_ctime(inode);
650 struct timespec64 mtime = inode_get_mtime(inode);
651 struct timespec64 now;
652 int updated = 0;
653
654 now = inode_set_ctime_current(inode);
655 if (!timespec64_equal(&now, &ctime))
656 updated |= S_CTIME;
657
658 inode_set_mtime_to_ts(inode, attr->ia_mtime);
659 if (!timespec64_equal(&now, &mtime))
660 updated |= S_MTIME;
661
662 inode_maybe_inc_iversion(inode, updated);
663 cache_flags |= NFS_INO_INVALID_CTIME | NFS_INO_INVALID_MTIME;
664 }
665 if (attr->ia_valid & ATTR_ATIME_SET) {
666 inode_set_atime_to_ts(inode, attr->ia_atime);
667 cache_flags |= NFS_INO_INVALID_ATIME;
668 }
669 NFS_I(inode)->cache_validity &= ~cache_flags;
670 }
671
nfs_update_timestamps(struct inode * inode,unsigned int ia_valid)672 static void nfs_update_timestamps(struct inode *inode, unsigned int ia_valid)
673 {
674 enum file_time_flags time_flags = 0;
675 unsigned int cache_flags = 0;
676
677 if (ia_valid & ATTR_MTIME) {
678 time_flags |= S_MTIME | S_CTIME;
679 cache_flags |= NFS_INO_INVALID_CTIME | NFS_INO_INVALID_MTIME;
680 }
681 if (ia_valid & ATTR_ATIME) {
682 time_flags |= S_ATIME;
683 cache_flags |= NFS_INO_INVALID_ATIME;
684 }
685 inode_update_timestamps(inode, time_flags);
686 NFS_I(inode)->cache_validity &= ~cache_flags;
687 }
688
nfs_update_delegated_atime(struct inode * inode)689 void nfs_update_delegated_atime(struct inode *inode)
690 {
691 spin_lock(&inode->i_lock);
692 if (nfs_have_delegated_atime(inode))
693 nfs_update_timestamps(inode, ATTR_ATIME);
694 spin_unlock(&inode->i_lock);
695 }
696
nfs_update_delegated_mtime_locked(struct inode * inode)697 void nfs_update_delegated_mtime_locked(struct inode *inode)
698 {
699 if (nfs_have_delegated_mtime(inode))
700 nfs_update_timestamps(inode, ATTR_MTIME);
701 }
702
nfs_update_delegated_mtime(struct inode * inode)703 void nfs_update_delegated_mtime(struct inode *inode)
704 {
705 spin_lock(&inode->i_lock);
706 nfs_update_delegated_mtime_locked(inode);
707 spin_unlock(&inode->i_lock);
708 }
709 EXPORT_SYMBOL_GPL(nfs_update_delegated_mtime);
710
711 #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)
712
713 int
nfs_setattr(struct mnt_idmap * idmap,struct dentry * dentry,struct iattr * attr)714 nfs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
715 struct iattr *attr)
716 {
717 struct inode *inode = d_inode(dentry);
718 struct nfs_fattr *fattr;
719 loff_t oldsize = i_size_read(inode);
720 int error = 0;
721 kuid_t task_uid = current_fsuid();
722 kuid_t owner_uid = inode->i_uid;
723
724 nfs_inc_stats(inode, NFSIOS_VFSSETATTR);
725
726 /* skip mode change if it's just for clearing setuid/setgid */
727 if (attr->ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID))
728 attr->ia_valid &= ~ATTR_MODE;
729
730 if (attr->ia_valid & ATTR_SIZE) {
731 BUG_ON(!S_ISREG(inode->i_mode));
732
733 error = inode_newsize_ok(inode, attr->ia_size);
734 if (error)
735 return error;
736
737 if (attr->ia_size == oldsize)
738 attr->ia_valid &= ~ATTR_SIZE;
739 }
740
741 if (nfs_have_delegated_mtime(inode) && attr->ia_valid & ATTR_MTIME) {
742 spin_lock(&inode->i_lock);
743 if (attr->ia_valid & ATTR_MTIME_SET) {
744 if (uid_eq(task_uid, owner_uid)) {
745 nfs_set_timestamps_to_ts(inode, attr);
746 attr->ia_valid &= ~(ATTR_MTIME|ATTR_MTIME_SET|
747 ATTR_ATIME|ATTR_ATIME_SET);
748 }
749 } else {
750 nfs_update_timestamps(inode, attr->ia_valid);
751 attr->ia_valid &= ~(ATTR_MTIME|ATTR_ATIME);
752 }
753 spin_unlock(&inode->i_lock);
754 } else if (nfs_have_delegated_atime(inode) &&
755 attr->ia_valid & ATTR_ATIME &&
756 !(attr->ia_valid & ATTR_MTIME)) {
757 if (attr->ia_valid & ATTR_ATIME_SET) {
758 if (uid_eq(task_uid, owner_uid)) {
759 spin_lock(&inode->i_lock);
760 nfs_set_timestamps_to_ts(inode, attr);
761 spin_unlock(&inode->i_lock);
762 attr->ia_valid &= ~(ATTR_ATIME|ATTR_ATIME_SET);
763 }
764 } else {
765 nfs_update_delegated_atime(inode);
766 attr->ia_valid &= ~ATTR_ATIME;
767 }
768 }
769
770 /* Optimization: if the end result is no change, don't RPC */
771 if (((attr->ia_valid & NFS_VALID_ATTRS) & ~(ATTR_FILE|ATTR_OPEN)) == 0)
772 return 0;
773
774 trace_nfs_setattr_enter(inode);
775
776 /* Write all dirty data */
777 if (S_ISREG(inode->i_mode)) {
778 nfs_file_block_o_direct(NFS_I(inode));
779 nfs_sync_inode(inode);
780 }
781
782 fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode));
783 if (fattr == NULL) {
784 error = -ENOMEM;
785 goto out;
786 }
787
788 error = NFS_PROTO(inode)->setattr(dentry, fattr, attr);
789 if (error == 0) {
790 if (attr->ia_valid & ATTR_SIZE)
791 nfs_truncate_last_folio(inode->i_mapping, oldsize,
792 attr->ia_size);
793 error = nfs_refresh_inode(inode, fattr);
794 }
795 nfs_free_fattr(fattr);
796 out:
797 trace_nfs_setattr_exit(inode, error);
798 return error;
799 }
800 EXPORT_SYMBOL_GPL(nfs_setattr);
801
802 /**
803 * nfs_vmtruncate - unmap mappings "freed" by truncate() syscall
804 * @inode: inode of the file used
805 * @offset: file offset to start truncating
806 *
807 * This is a copy of the common vmtruncate, but with the locking
808 * corrected to take into account the fact that NFS requires
809 * inode->i_size to be updated under the inode->i_lock.
810 * Note: must be called with inode->i_lock held!
811 */
nfs_vmtruncate(struct inode * inode,loff_t offset)812 static int nfs_vmtruncate(struct inode * inode, loff_t offset)
813 {
814 int err;
815
816 err = inode_newsize_ok(inode, offset);
817 if (err)
818 goto out;
819
820 trace_nfs_size_truncate(inode, offset);
821 i_size_write(inode, offset);
822 /* Optimisation */
823 if (offset == 0) {
824 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_DATA;
825 nfs_ooo_clear(NFS_I(inode));
826 }
827 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_SIZE;
828
829 spin_unlock(&inode->i_lock);
830 truncate_pagecache(inode, offset);
831 nfs_update_delegated_mtime_locked(inode);
832 spin_lock(&inode->i_lock);
833 out:
834 return err;
835 }
836
837 /**
838 * nfs_setattr_update_inode - Update inode metadata after a setattr call.
839 * @inode: pointer to struct inode
840 * @attr: pointer to struct iattr
841 * @fattr: pointer to struct nfs_fattr
842 *
843 * Note: we do this in the *proc.c in order to ensure that
844 * it works for things like exclusive creates too.
845 */
nfs_setattr_update_inode(struct inode * inode,struct iattr * attr,struct nfs_fattr * fattr)846 void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr,
847 struct nfs_fattr *fattr)
848 {
849 /* Barrier: bump the attribute generation count. */
850 nfs_fattr_set_barrier(fattr);
851
852 spin_lock(&inode->i_lock);
853 NFS_I(inode)->attr_gencount = fattr->gencount;
854 if ((attr->ia_valid & ATTR_SIZE) != 0) {
855 if (!nfs_have_delegated_mtime(inode))
856 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME);
857 nfs_set_cache_invalid(inode, NFS_INO_INVALID_BLOCKS);
858 nfs_inc_stats(inode, NFSIOS_SETATTRTRUNC);
859 nfs_vmtruncate(inode, attr->ia_size);
860 }
861 if ((attr->ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID)) != 0) {
862 NFS_I(inode)->cache_validity &= ~NFS_INO_INVALID_CTIME;
863 if ((attr->ia_valid & ATTR_KILL_SUID) != 0 &&
864 inode->i_mode & S_ISUID)
865 inode->i_mode &= ~S_ISUID;
866 if (setattr_should_drop_sgid(&nop_mnt_idmap, inode))
867 inode->i_mode &= ~S_ISGID;
868 if ((attr->ia_valid & ATTR_MODE) != 0) {
869 int mode = attr->ia_mode & S_IALLUGO;
870 mode |= inode->i_mode & ~S_IALLUGO;
871 inode->i_mode = mode;
872 }
873 if ((attr->ia_valid & ATTR_UID) != 0)
874 inode->i_uid = attr->ia_uid;
875 if ((attr->ia_valid & ATTR_GID) != 0)
876 inode->i_gid = attr->ia_gid;
877 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
878 inode_set_ctime_to_ts(inode, fattr->ctime);
879 else
880 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE
881 | NFS_INO_INVALID_CTIME);
882 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ACCESS
883 | NFS_INO_INVALID_ACL);
884 }
885 if (attr->ia_valid & (ATTR_ATIME_SET|ATTR_ATIME)) {
886 NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_ATIME
887 | NFS_INO_INVALID_CTIME);
888 if (fattr->valid & NFS_ATTR_FATTR_ATIME)
889 inode_set_atime_to_ts(inode, fattr->atime);
890 else if (attr->ia_valid & ATTR_ATIME_SET)
891 inode_set_atime_to_ts(inode, attr->ia_atime);
892 else
893 nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATIME);
894
895 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
896 inode_set_ctime_to_ts(inode, fattr->ctime);
897 else
898 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE
899 | NFS_INO_INVALID_CTIME);
900 }
901 if (attr->ia_valid & (ATTR_MTIME_SET|ATTR_MTIME)) {
902 NFS_I(inode)->cache_validity &= ~(NFS_INO_INVALID_MTIME
903 | NFS_INO_INVALID_CTIME);
904 if (fattr->valid & NFS_ATTR_FATTR_MTIME)
905 inode_set_mtime_to_ts(inode, fattr->mtime);
906 else if (attr->ia_valid & ATTR_MTIME_SET)
907 inode_set_mtime_to_ts(inode, attr->ia_mtime);
908 else
909 nfs_set_cache_invalid(inode, NFS_INO_INVALID_MTIME);
910
911 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
912 inode_set_ctime_to_ts(inode, fattr->ctime);
913 else
914 nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE
915 | NFS_INO_INVALID_CTIME);
916 }
917 if (fattr->valid)
918 nfs_update_inode(inode, fattr);
919 spin_unlock(&inode->i_lock);
920 }
921 EXPORT_SYMBOL_GPL(nfs_setattr_update_inode);
922
923 /*
924 * Don't request help from readdirplus if the file is being written to,
925 * or if attribute caching is turned off
926 */
nfs_getattr_readdirplus_enable(const struct inode * inode)927 static bool nfs_getattr_readdirplus_enable(const struct inode *inode)
928 {
929 return nfs_server_capable(inode, NFS_CAP_READDIRPLUS) &&
930 !nfs_have_writebacks(inode) && NFS_MAXATTRTIMEO(inode) > 5 * HZ;
931 }
932
nfs_readdirplus_parent_cache_miss(struct dentry * dentry)933 static void nfs_readdirplus_parent_cache_miss(struct dentry *dentry)
934 {
935 if (!IS_ROOT(dentry)) {
936 struct dentry *parent = dget_parent(dentry);
937 nfs_readdir_record_entry_cache_miss(d_inode(parent));
938 dput(parent);
939 }
940 }
941
nfs_readdirplus_parent_cache_hit(struct dentry * dentry)942 static void nfs_readdirplus_parent_cache_hit(struct dentry *dentry)
943 {
944 if (!IS_ROOT(dentry)) {
945 struct dentry *parent = dget_parent(dentry);
946 nfs_readdir_record_entry_cache_hit(d_inode(parent));
947 dput(parent);
948 }
949 }
950
nfs_get_valid_attrmask(struct inode * inode)951 static u32 nfs_get_valid_attrmask(struct inode *inode)
952 {
953 u64 fattr_valid = NFS_SERVER(inode)->fattr_valid;
954 unsigned long cache_validity = READ_ONCE(NFS_I(inode)->cache_validity);
955 u32 reply_mask = STATX_INO | STATX_TYPE;
956
957 if (!(cache_validity & NFS_INO_INVALID_ATIME))
958 reply_mask |= STATX_ATIME;
959 if (!(cache_validity & NFS_INO_INVALID_CTIME))
960 reply_mask |= STATX_CTIME;
961 if (!(cache_validity & NFS_INO_INVALID_MTIME))
962 reply_mask |= STATX_MTIME;
963 if (!(cache_validity & NFS_INO_INVALID_SIZE))
964 reply_mask |= STATX_SIZE;
965 if (!(cache_validity & NFS_INO_INVALID_NLINK))
966 reply_mask |= STATX_NLINK;
967 if (!(cache_validity & NFS_INO_INVALID_MODE))
968 reply_mask |= STATX_MODE;
969 if (!(cache_validity & NFS_INO_INVALID_OTHER))
970 reply_mask |= STATX_UID | STATX_GID;
971 if (!(cache_validity & NFS_INO_INVALID_BLOCKS))
972 reply_mask |= STATX_BLOCKS;
973 if (!(cache_validity & NFS_INO_INVALID_BTIME) &&
974 (fattr_valid & NFS_ATTR_FATTR_BTIME))
975 reply_mask |= STATX_BTIME;
976 if (!(cache_validity & NFS_INO_INVALID_CHANGE))
977 reply_mask |= STATX_CHANGE_COOKIE;
978 return reply_mask;
979 }
980
nfs_getattr(struct mnt_idmap * idmap,const struct path * path,struct kstat * stat,u32 request_mask,unsigned int query_flags)981 int nfs_getattr(struct mnt_idmap *idmap, const struct path *path,
982 struct kstat *stat, u32 request_mask, unsigned int query_flags)
983 {
984 struct inode *inode = d_inode(path->dentry);
985 struct nfs_server *server = NFS_SERVER(inode);
986 u64 fattr_valid = server->fattr_valid;
987 unsigned long cache_validity;
988 int err = 0;
989 bool force_sync = query_flags & AT_STATX_FORCE_SYNC;
990 bool do_update = false;
991 bool readdirplus_enabled = nfs_getattr_readdirplus_enable(inode);
992
993 trace_nfs_getattr_enter(inode);
994
995 request_mask &= STATX_TYPE | STATX_MODE | STATX_NLINK | STATX_UID |
996 STATX_GID | STATX_ATIME | STATX_MTIME | STATX_CTIME |
997 STATX_INO | STATX_SIZE | STATX_BLOCKS | STATX_BTIME |
998 STATX_CHANGE_COOKIE;
999
1000 if (!(fattr_valid & NFS_ATTR_FATTR_BTIME))
1001 request_mask &= ~STATX_BTIME;
1002
1003 if ((query_flags & AT_STATX_DONT_SYNC) && !force_sync) {
1004 if (readdirplus_enabled)
1005 nfs_readdirplus_parent_cache_hit(path->dentry);
1006 goto out_no_revalidate;
1007 }
1008
1009 /* Flush out writes to the server in order to update c/mtime/version. */
1010 if ((request_mask & (STATX_CTIME | STATX_MTIME | STATX_CHANGE_COOKIE)) &&
1011 S_ISREG(inode->i_mode)) {
1012 if (nfs_have_delegated_mtime(inode))
1013 filemap_fdatawrite(inode->i_mapping);
1014 else
1015 filemap_write_and_wait(inode->i_mapping);
1016 }
1017
1018 /*
1019 * We may force a getattr if the user cares about atime.
1020 *
1021 * Note that we only have to check the vfsmount flags here:
1022 * - NFS always sets S_NOATIME by so checking it would give a
1023 * bogus result
1024 * - NFS never sets SB_NOATIME or SB_NODIRATIME so there is
1025 * no point in checking those.
1026 */
1027 if ((path->mnt->mnt_flags & MNT_NOATIME) ||
1028 ((path->mnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
1029 request_mask &= ~STATX_ATIME;
1030
1031 /* Is the user requesting attributes that might need revalidation? */
1032 if (!(request_mask & (STATX_MODE|STATX_NLINK|STATX_ATIME|STATX_CTIME|
1033 STATX_MTIME|STATX_UID|STATX_GID|
1034 STATX_SIZE|STATX_BLOCKS|STATX_BTIME|
1035 STATX_CHANGE_COOKIE)))
1036 goto out_no_revalidate;
1037
1038 /* Check whether the cached attributes are stale */
1039 do_update |= force_sync || nfs_attribute_cache_expired(inode);
1040 cache_validity = READ_ONCE(NFS_I(inode)->cache_validity);
1041 do_update |= cache_validity & NFS_INO_INVALID_CHANGE;
1042 if (request_mask & STATX_ATIME)
1043 do_update |= cache_validity & NFS_INO_INVALID_ATIME;
1044 if (request_mask & STATX_CTIME)
1045 do_update |= cache_validity & NFS_INO_INVALID_CTIME;
1046 if (request_mask & STATX_MTIME)
1047 do_update |= cache_validity & NFS_INO_INVALID_MTIME;
1048 if (request_mask & STATX_SIZE)
1049 do_update |= cache_validity & NFS_INO_INVALID_SIZE;
1050 if (request_mask & STATX_NLINK)
1051 do_update |= cache_validity & NFS_INO_INVALID_NLINK;
1052 if (request_mask & STATX_MODE)
1053 do_update |= cache_validity & NFS_INO_INVALID_MODE;
1054 if (request_mask & (STATX_UID | STATX_GID))
1055 do_update |= cache_validity & NFS_INO_INVALID_OTHER;
1056 if (request_mask & STATX_BLOCKS)
1057 do_update |= cache_validity & NFS_INO_INVALID_BLOCKS;
1058 if (request_mask & STATX_BTIME)
1059 do_update |= cache_validity & NFS_INO_INVALID_BTIME;
1060
1061 if (do_update) {
1062 if (readdirplus_enabled)
1063 nfs_readdirplus_parent_cache_miss(path->dentry);
1064 err = __nfs_revalidate_inode(server, inode);
1065 if (err)
1066 goto out;
1067 } else if (readdirplus_enabled)
1068 nfs_readdirplus_parent_cache_hit(path->dentry);
1069 out_no_revalidate:
1070 /* Only return attributes that were revalidated. */
1071 stat->result_mask = nfs_get_valid_attrmask(inode) | request_mask;
1072
1073 generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
1074 stat->ino = nfs_compat_user_ino64(NFS_FILEID(inode));
1075 stat->change_cookie = inode_peek_iversion_raw(inode);
1076 stat->attributes_mask |= STATX_ATTR_CHANGE_MONOTONIC;
1077 if (server->change_attr_type != NFS4_CHANGE_TYPE_IS_UNDEFINED)
1078 stat->attributes |= STATX_ATTR_CHANGE_MONOTONIC;
1079 if (S_ISDIR(inode->i_mode))
1080 stat->blksize = NFS_SERVER(inode)->dtsize;
1081 stat->btime = NFS_I(inode)->btime;
1082
1083 /* Special handling for STATX_DIOALIGN and STATX_DIO_READ_ALIGN
1084 * - NFS doesn't have DIO alignment constraints, avoid getting
1085 * these DIO attrs from remote and just respond with most
1086 * accommodating limits (so client will issue supported DIO).
1087 * - this is unintuitive, but the most coarse-grained
1088 * dio_offset_align is the most accommodating.
1089 */
1090 if ((request_mask & (STATX_DIOALIGN | STATX_DIO_READ_ALIGN)) &&
1091 S_ISREG(inode->i_mode)) {
1092 stat->result_mask |= STATX_DIOALIGN | STATX_DIO_READ_ALIGN;
1093 stat->dio_mem_align = 4; /* 4-byte alignment */
1094 stat->dio_offset_align = PAGE_SIZE;
1095 stat->dio_read_offset_align = stat->dio_offset_align;
1096 }
1097 out:
1098 trace_nfs_getattr_exit(inode, err);
1099 return err;
1100 }
1101 EXPORT_SYMBOL_GPL(nfs_getattr);
1102
nfs_init_lock_context(struct nfs_lock_context * l_ctx)1103 static void nfs_init_lock_context(struct nfs_lock_context *l_ctx)
1104 {
1105 refcount_set(&l_ctx->count, 1);
1106 l_ctx->lockowner = current->files;
1107 INIT_LIST_HEAD(&l_ctx->list);
1108 atomic_set(&l_ctx->io_count, 0);
1109 }
1110
__nfs_find_lock_context(struct nfs_open_context * ctx)1111 static struct nfs_lock_context *__nfs_find_lock_context(struct nfs_open_context *ctx)
1112 {
1113 struct nfs_lock_context *pos;
1114
1115 list_for_each_entry_rcu(pos, &ctx->lock_context.list, list) {
1116 if (pos->lockowner != current->files)
1117 continue;
1118 if (refcount_inc_not_zero(&pos->count))
1119 return pos;
1120 }
1121 return NULL;
1122 }
1123
nfs_get_lock_context(struct nfs_open_context * ctx)1124 struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx)
1125 {
1126 struct nfs_lock_context *res, *new = NULL;
1127 struct inode *inode = d_inode(ctx->dentry);
1128
1129 rcu_read_lock();
1130 res = __nfs_find_lock_context(ctx);
1131 rcu_read_unlock();
1132 if (res == NULL) {
1133 new = kmalloc(sizeof(*new), GFP_KERNEL_ACCOUNT);
1134 if (new == NULL)
1135 return ERR_PTR(-ENOMEM);
1136 nfs_init_lock_context(new);
1137 spin_lock(&inode->i_lock);
1138 res = __nfs_find_lock_context(ctx);
1139 if (res == NULL) {
1140 new->open_context = get_nfs_open_context(ctx);
1141 if (new->open_context) {
1142 list_add_tail_rcu(&new->list,
1143 &ctx->lock_context.list);
1144 res = new;
1145 new = NULL;
1146 } else
1147 res = ERR_PTR(-EBADF);
1148 }
1149 spin_unlock(&inode->i_lock);
1150 kfree(new);
1151 }
1152 return res;
1153 }
1154 EXPORT_SYMBOL_GPL(nfs_get_lock_context);
1155
nfs_put_lock_context(struct nfs_lock_context * l_ctx)1156 void nfs_put_lock_context(struct nfs_lock_context *l_ctx)
1157 {
1158 struct nfs_open_context *ctx = l_ctx->open_context;
1159 struct inode *inode = d_inode(ctx->dentry);
1160
1161 if (!refcount_dec_and_lock(&l_ctx->count, &inode->i_lock))
1162 return;
1163 list_del_rcu(&l_ctx->list);
1164 spin_unlock(&inode->i_lock);
1165 put_nfs_open_context(ctx);
1166 kfree_rcu(l_ctx, rcu_head);
1167 }
1168 EXPORT_SYMBOL_GPL(nfs_put_lock_context);
1169
1170 /**
1171 * nfs_close_context - Common close_context() routine NFSv2/v3
1172 * @ctx: pointer to context
1173 * @is_sync: is this a synchronous close
1174 *
1175 * Ensure that the attributes are up to date if we're mounted
1176 * with close-to-open semantics and we have cached data that will
1177 * need to be revalidated on open.
1178 */
nfs_close_context(struct nfs_open_context * ctx,int is_sync)1179 void nfs_close_context(struct nfs_open_context *ctx, int is_sync)
1180 {
1181 struct nfs_inode *nfsi;
1182 struct inode *inode;
1183
1184 if (!(ctx->mode & FMODE_WRITE))
1185 return;
1186 if (!is_sync)
1187 return;
1188 inode = d_inode(ctx->dentry);
1189 if (nfs_have_read_or_write_delegation(inode))
1190 return;
1191 nfsi = NFS_I(inode);
1192 if (inode->i_mapping->nrpages == 0)
1193 return;
1194 if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
1195 return;
1196 if (!list_empty(&nfsi->open_files))
1197 return;
1198 if (NFS_SERVER(inode)->flags & NFS_MOUNT_NOCTO)
1199 return;
1200 nfs_revalidate_inode(inode,
1201 NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_SIZE);
1202 }
1203 EXPORT_SYMBOL_GPL(nfs_close_context);
1204
alloc_nfs_open_context(struct dentry * dentry,fmode_t f_mode,struct file * filp)1205 struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry,
1206 fmode_t f_mode,
1207 struct file *filp)
1208 {
1209 struct nfs_open_context *ctx;
1210
1211 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL_ACCOUNT);
1212 if (!ctx)
1213 return ERR_PTR(-ENOMEM);
1214 nfs_sb_active(dentry->d_sb);
1215 ctx->dentry = dget(dentry);
1216 if (filp)
1217 ctx->cred = get_cred(filp->f_cred);
1218 else
1219 ctx->cred = get_current_cred();
1220 rcu_assign_pointer(ctx->ll_cred, NULL);
1221 ctx->state = NULL;
1222 ctx->mode = f_mode;
1223 ctx->flags = 0;
1224 ctx->error = 0;
1225 ctx->flock_owner = (fl_owner_t)filp;
1226 nfs_init_lock_context(&ctx->lock_context);
1227 ctx->lock_context.open_context = ctx;
1228 INIT_LIST_HEAD(&ctx->list);
1229 ctx->mdsthreshold = NULL;
1230 nfs_localio_file_init(&ctx->nfl);
1231
1232 return ctx;
1233 }
1234 EXPORT_SYMBOL_GPL(alloc_nfs_open_context);
1235
get_nfs_open_context(struct nfs_open_context * ctx)1236 struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
1237 {
1238 if (ctx != NULL && refcount_inc_not_zero(&ctx->lock_context.count))
1239 return ctx;
1240 return NULL;
1241 }
1242 EXPORT_SYMBOL_GPL(get_nfs_open_context);
1243
__put_nfs_open_context(struct nfs_open_context * ctx,int is_sync)1244 static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync)
1245 {
1246 struct inode *inode = d_inode(ctx->dentry);
1247 struct super_block *sb = ctx->dentry->d_sb;
1248
1249 if (!refcount_dec_and_test(&ctx->lock_context.count))
1250 return;
1251 if (!list_empty(&ctx->list)) {
1252 spin_lock(&inode->i_lock);
1253 list_del_rcu(&ctx->list);
1254 spin_unlock(&inode->i_lock);
1255 }
1256 if (inode != NULL)
1257 NFS_PROTO(inode)->close_context(ctx, is_sync);
1258 put_cred(ctx->cred);
1259 dput(ctx->dentry);
1260 nfs_sb_deactive(sb);
1261 put_rpccred(rcu_dereference_protected(ctx->ll_cred, 1));
1262 kfree(ctx->mdsthreshold);
1263 nfs_close_local_fh(&ctx->nfl);
1264 kfree_rcu(ctx, rcu_head);
1265 }
1266
put_nfs_open_context(struct nfs_open_context * ctx)1267 void put_nfs_open_context(struct nfs_open_context *ctx)
1268 {
1269 __put_nfs_open_context(ctx, 0);
1270 }
1271 EXPORT_SYMBOL_GPL(put_nfs_open_context);
1272
put_nfs_open_context_sync(struct nfs_open_context * ctx)1273 static void put_nfs_open_context_sync(struct nfs_open_context *ctx)
1274 {
1275 __put_nfs_open_context(ctx, 1);
1276 }
1277
1278 /*
1279 * Ensure that mmap has a recent RPC credential for use when writing out
1280 * shared pages
1281 */
nfs_inode_attach_open_context(struct nfs_open_context * ctx)1282 void nfs_inode_attach_open_context(struct nfs_open_context *ctx)
1283 {
1284 struct inode *inode = d_inode(ctx->dentry);
1285 struct nfs_inode *nfsi = NFS_I(inode);
1286
1287 spin_lock(&inode->i_lock);
1288 if (list_empty(&nfsi->open_files) &&
1289 nfs_ooo_test(nfsi))
1290 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA |
1291 NFS_INO_REVAL_FORCED);
1292 list_add_tail_rcu(&ctx->list, &nfsi->open_files);
1293 spin_unlock(&inode->i_lock);
1294 }
1295 EXPORT_SYMBOL_GPL(nfs_inode_attach_open_context);
1296
nfs_file_set_open_context(struct file * filp,struct nfs_open_context * ctx)1297 void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx)
1298 {
1299 filp->private_data = get_nfs_open_context(ctx);
1300 set_bit(NFS_CONTEXT_FILE_OPEN, &ctx->flags);
1301 if (list_empty(&ctx->list))
1302 nfs_inode_attach_open_context(ctx);
1303 }
1304 EXPORT_SYMBOL_GPL(nfs_file_set_open_context);
1305
1306 /*
1307 * Given an inode, search for an open context with the desired characteristics
1308 */
nfs_find_open_context(struct inode * inode,const struct cred * cred,fmode_t mode)1309 struct nfs_open_context *nfs_find_open_context(struct inode *inode, const struct cred *cred, fmode_t mode)
1310 {
1311 struct nfs_inode *nfsi = NFS_I(inode);
1312 struct nfs_open_context *pos, *ctx = NULL;
1313
1314 rcu_read_lock();
1315 list_for_each_entry_rcu(pos, &nfsi->open_files, list) {
1316 if (cred != NULL && cred_fscmp(pos->cred, cred) != 0)
1317 continue;
1318 if ((pos->mode & (FMODE_READ|FMODE_WRITE)) != mode)
1319 continue;
1320 if (!test_bit(NFS_CONTEXT_FILE_OPEN, &pos->flags))
1321 continue;
1322 ctx = get_nfs_open_context(pos);
1323 if (ctx)
1324 break;
1325 }
1326 rcu_read_unlock();
1327 return ctx;
1328 }
1329
nfs_file_clear_open_context(struct file * filp)1330 void nfs_file_clear_open_context(struct file *filp)
1331 {
1332 struct nfs_open_context *ctx = nfs_file_open_context(filp);
1333
1334 if (ctx) {
1335 struct inode *inode = d_inode(ctx->dentry);
1336
1337 clear_bit(NFS_CONTEXT_FILE_OPEN, &ctx->flags);
1338 /*
1339 * We fatal error on write before. Try to writeback
1340 * every page again.
1341 */
1342 if (ctx->error < 0)
1343 invalidate_inode_pages2(inode->i_mapping);
1344 filp->private_data = NULL;
1345 put_nfs_open_context_sync(ctx);
1346 }
1347 }
1348
1349 /*
1350 * These allocate and release file read/write context information.
1351 */
nfs_open(struct inode * inode,struct file * filp)1352 int nfs_open(struct inode *inode, struct file *filp)
1353 {
1354 struct nfs_open_context *ctx;
1355
1356 ctx = alloc_nfs_open_context(file_dentry(filp),
1357 flags_to_mode(filp->f_flags), filp);
1358 if (IS_ERR(ctx))
1359 return PTR_ERR(ctx);
1360 nfs_file_set_open_context(filp, ctx);
1361 put_nfs_open_context(ctx);
1362 nfs_fscache_open_file(inode, filp);
1363 return 0;
1364 }
1365
1366 /*
1367 * This function is called whenever some part of NFS notices that
1368 * the cached attributes have to be refreshed.
1369 */
1370 int
__nfs_revalidate_inode(struct nfs_server * server,struct inode * inode)1371 __nfs_revalidate_inode(struct nfs_server *server, struct inode *inode)
1372 {
1373 int status = -ESTALE;
1374 struct nfs_fattr *fattr = NULL;
1375 struct nfs_inode *nfsi = NFS_I(inode);
1376
1377 dfprintk(PAGECACHE, "NFS: revalidating (%s/%Lu)\n",
1378 inode->i_sb->s_id, (unsigned long long)NFS_FILEID(inode));
1379
1380 trace_nfs_revalidate_inode_enter(inode);
1381
1382 if (is_bad_inode(inode))
1383 goto out;
1384 if (NFS_STALE(inode))
1385 goto out;
1386
1387 /* pNFS: Attributes aren't updated until we layoutcommit */
1388 if (S_ISREG(inode->i_mode)) {
1389 status = pnfs_sync_inode(inode, false);
1390 if (status)
1391 goto out;
1392 } else if (nfs_have_directory_delegation(inode)) {
1393 status = 0;
1394 goto out;
1395 }
1396
1397 status = -ENOMEM;
1398 fattr = nfs_alloc_fattr_with_label(NFS_SERVER(inode));
1399 if (fattr == NULL)
1400 goto out;
1401
1402 nfs_inc_stats(inode, NFSIOS_INODEREVALIDATE);
1403
1404 status = NFS_PROTO(inode)->getattr(server, NFS_FH(inode), fattr, inode);
1405 if (status != 0) {
1406 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) getattr failed, error=%d\n",
1407 inode->i_sb->s_id,
1408 (unsigned long long)NFS_FILEID(inode), status);
1409 switch (status) {
1410 case -ETIMEDOUT:
1411 /* A soft timeout occurred. Use cached information? */
1412 if (server->flags & NFS_MOUNT_SOFTREVAL)
1413 status = 0;
1414 break;
1415 case -ESTALE:
1416 if (!S_ISDIR(inode->i_mode))
1417 nfs_set_inode_stale(inode);
1418 else
1419 nfs_zap_caches(inode);
1420 }
1421 goto out;
1422 }
1423
1424 status = nfs_refresh_inode(inode, fattr);
1425 if (status) {
1426 dfprintk(PAGECACHE, "nfs_revalidate_inode: (%s/%Lu) refresh failed, error=%d\n",
1427 inode->i_sb->s_id,
1428 (unsigned long long)NFS_FILEID(inode), status);
1429 goto out;
1430 }
1431
1432 if (nfsi->cache_validity & NFS_INO_INVALID_ACL)
1433 nfs_zap_acl_cache(inode);
1434
1435 nfs_setsecurity(inode, fattr);
1436
1437 dfprintk(PAGECACHE, "NFS: (%s/%Lu) revalidation complete\n",
1438 inode->i_sb->s_id,
1439 (unsigned long long)NFS_FILEID(inode));
1440
1441 out:
1442 nfs_free_fattr(fattr);
1443 trace_nfs_revalidate_inode_exit(inode, status);
1444 return status;
1445 }
1446
nfs_attribute_cache_expired(struct inode * inode)1447 int nfs_attribute_cache_expired(struct inode *inode)
1448 {
1449 if (nfs_have_delegated_attributes(inode))
1450 return 0;
1451 return nfs_attribute_timeout(inode);
1452 }
1453
1454 /**
1455 * nfs_revalidate_inode - Revalidate the inode attributes
1456 * @inode: pointer to inode struct
1457 * @flags: cache flags to check
1458 *
1459 * Updates inode attribute information by retrieving the data from the server.
1460 */
nfs_revalidate_inode(struct inode * inode,unsigned long flags)1461 int nfs_revalidate_inode(struct inode *inode, unsigned long flags)
1462 {
1463 if (!nfs_check_cache_invalid(inode, flags))
1464 return NFS_STALE(inode) ? -ESTALE : 0;
1465 return __nfs_revalidate_inode(NFS_SERVER(inode), inode);
1466 }
1467 EXPORT_SYMBOL_GPL(nfs_revalidate_inode);
1468
nfs_invalidate_mapping(struct inode * inode,struct address_space * mapping)1469 static int nfs_invalidate_mapping(struct inode *inode, struct address_space *mapping)
1470 {
1471 int ret;
1472
1473 nfs_fscache_invalidate(inode, 0);
1474 if (mapping->nrpages != 0) {
1475 if (S_ISREG(inode->i_mode)) {
1476 ret = nfs_sync_mapping(mapping);
1477 if (ret < 0)
1478 return ret;
1479 }
1480 ret = invalidate_inode_pages2(mapping);
1481 if (ret < 0)
1482 return ret;
1483 }
1484 nfs_inc_stats(inode, NFSIOS_DATAINVALIDATE);
1485
1486 dfprintk(PAGECACHE, "NFS: (%s/%Lu) data cache invalidated\n",
1487 inode->i_sb->s_id,
1488 (unsigned long long)NFS_FILEID(inode));
1489 return 0;
1490 }
1491
1492 /**
1493 * nfs_clear_invalid_mapping - Conditionally clear a mapping
1494 * @mapping: pointer to mapping
1495 *
1496 * If the NFS_INO_INVALID_DATA inode flag is set, clear the mapping.
1497 */
nfs_clear_invalid_mapping(struct address_space * mapping)1498 int nfs_clear_invalid_mapping(struct address_space *mapping)
1499 {
1500 struct inode *inode = mapping->host;
1501 struct nfs_inode *nfsi = NFS_I(inode);
1502 unsigned long *bitlock = &nfsi->flags;
1503 int ret = 0;
1504
1505 /*
1506 * We must clear NFS_INO_INVALID_DATA first to ensure that
1507 * invalidations that come in while we're shooting down the mappings
1508 * are respected. But, that leaves a race window where one revalidator
1509 * can clear the flag, and then another checks it before the mapping
1510 * gets invalidated. Fix that by serializing access to this part of
1511 * the function.
1512 *
1513 * At the same time, we need to allow other tasks to see whether we
1514 * might be in the middle of invalidating the pages, so we only set
1515 * the bit lock here if it looks like we're going to be doing that.
1516 */
1517 for (;;) {
1518 ret = wait_on_bit_action(bitlock, NFS_INO_INVALIDATING,
1519 nfs_wait_bit_killable,
1520 TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
1521 if (ret)
1522 goto out;
1523 smp_rmb(); /* pairs with smp_wmb() below */
1524 if (test_bit(NFS_INO_INVALIDATING, bitlock))
1525 continue;
1526 /* pairs with nfs_set_cache_invalid()'s smp_store_release() */
1527 if (!(smp_load_acquire(&nfsi->cache_validity) & NFS_INO_INVALID_DATA))
1528 goto out;
1529 /* Slow-path that double-checks with spinlock held */
1530 spin_lock(&inode->i_lock);
1531 if (test_bit(NFS_INO_INVALIDATING, bitlock)) {
1532 spin_unlock(&inode->i_lock);
1533 continue;
1534 }
1535 if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
1536 break;
1537 spin_unlock(&inode->i_lock);
1538 goto out;
1539 }
1540
1541 set_bit(NFS_INO_INVALIDATING, bitlock);
1542 smp_wmb();
1543 nfsi->cache_validity &= ~NFS_INO_INVALID_DATA;
1544 nfs_ooo_clear(nfsi);
1545 spin_unlock(&inode->i_lock);
1546 trace_nfs_invalidate_mapping_enter(inode);
1547 ret = nfs_invalidate_mapping(inode, mapping);
1548 trace_nfs_invalidate_mapping_exit(inode, ret);
1549
1550 clear_bit_unlock(NFS_INO_INVALIDATING, bitlock);
1551 smp_mb__after_atomic();
1552 wake_up_bit(bitlock, NFS_INO_INVALIDATING);
1553 out:
1554 return ret;
1555 }
1556
nfs_mapping_need_revalidate_inode(struct inode * inode)1557 bool nfs_mapping_need_revalidate_inode(struct inode *inode)
1558 {
1559 return nfs_check_cache_invalid(inode, NFS_INO_INVALID_CHANGE) ||
1560 NFS_STALE(inode);
1561 }
1562
nfs_revalidate_mapping_rcu(struct inode * inode)1563 int nfs_revalidate_mapping_rcu(struct inode *inode)
1564 {
1565 struct nfs_inode *nfsi = NFS_I(inode);
1566 unsigned long *bitlock = &nfsi->flags;
1567 int ret = 0;
1568
1569 if (IS_SWAPFILE(inode))
1570 goto out;
1571 if (nfs_mapping_need_revalidate_inode(inode)) {
1572 ret = -ECHILD;
1573 goto out;
1574 }
1575 spin_lock(&inode->i_lock);
1576 if (test_bit(NFS_INO_INVALIDATING, bitlock) ||
1577 (nfsi->cache_validity & NFS_INO_INVALID_DATA))
1578 ret = -ECHILD;
1579 spin_unlock(&inode->i_lock);
1580 out:
1581 return ret;
1582 }
1583
1584 /**
1585 * nfs_revalidate_mapping - Revalidate the pagecache
1586 * @inode: pointer to host inode
1587 * @mapping: pointer to mapping
1588 */
nfs_revalidate_mapping(struct inode * inode,struct address_space * mapping)1589 int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping)
1590 {
1591 /* swapfiles are not supposed to be shared. */
1592 if (IS_SWAPFILE(inode))
1593 return 0;
1594
1595 if (nfs_mapping_need_revalidate_inode(inode)) {
1596 int ret = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
1597 if (ret < 0)
1598 return ret;
1599 }
1600
1601 return nfs_clear_invalid_mapping(mapping);
1602 }
1603
nfs_file_has_writers(struct nfs_inode * nfsi)1604 static bool nfs_file_has_writers(struct nfs_inode *nfsi)
1605 {
1606 struct inode *inode = &nfsi->vfs_inode;
1607
1608 if (!S_ISREG(inode->i_mode))
1609 return false;
1610 if (list_empty(&nfsi->open_files))
1611 return false;
1612 return inode_is_open_for_write(inode);
1613 }
1614
nfs_file_has_buffered_writers(struct nfs_inode * nfsi)1615 static bool nfs_file_has_buffered_writers(struct nfs_inode *nfsi)
1616 {
1617 return nfs_file_has_writers(nfsi) && nfs_file_io_is_buffered(nfsi);
1618 }
1619
nfs_wcc_update_inode(struct inode * inode,struct nfs_fattr * fattr)1620 static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
1621 {
1622 struct timespec64 ts;
1623
1624 if ((fattr->valid & NFS_ATTR_FATTR_PRECHANGE)
1625 && (fattr->valid & NFS_ATTR_FATTR_CHANGE)
1626 && inode_eq_iversion_raw(inode, fattr->pre_change_attr)) {
1627 inode_set_iversion_raw(inode, fattr->change_attr);
1628 if (S_ISDIR(inode->i_mode))
1629 nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
1630 else if (nfs_server_capable(inode, NFS_CAP_XATTR))
1631 nfs_set_cache_invalid(inode, NFS_INO_INVALID_XATTR);
1632 }
1633 /* If we have atomic WCC data, we may update some attributes */
1634 ts = inode_get_ctime(inode);
1635 if ((fattr->valid & NFS_ATTR_FATTR_PRECTIME)
1636 && (fattr->valid & NFS_ATTR_FATTR_CTIME)
1637 && timespec64_equal(&ts, &fattr->pre_ctime)) {
1638 inode_set_ctime_to_ts(inode, fattr->ctime);
1639 }
1640
1641 ts = inode_get_mtime(inode);
1642 if ((fattr->valid & NFS_ATTR_FATTR_PREMTIME)
1643 && (fattr->valid & NFS_ATTR_FATTR_MTIME)
1644 && timespec64_equal(&ts, &fattr->pre_mtime)) {
1645 inode_set_mtime_to_ts(inode, fattr->mtime);
1646 }
1647 if ((fattr->valid & NFS_ATTR_FATTR_PRESIZE)
1648 && (fattr->valid & NFS_ATTR_FATTR_SIZE)
1649 && i_size_read(inode) == nfs_size_to_loff_t(fattr->pre_size)
1650 && !nfs_have_writebacks(inode)) {
1651 trace_nfs_size_wcc(inode, fattr->size);
1652 i_size_write(inode, nfs_size_to_loff_t(fattr->size));
1653 }
1654 }
1655
1656 /**
1657 * nfs_check_inode_attributes - verify consistency of the inode attribute cache
1658 * @inode: pointer to inode
1659 * @fattr: updated attributes
1660 *
1661 * Verifies the attribute cache. If we have just changed the attributes,
1662 * so that fattr carries weak cache consistency data, then it may
1663 * also update the ctime/mtime/change_attribute.
1664 */
nfs_check_inode_attributes(struct inode * inode,struct nfs_fattr * fattr)1665 static int nfs_check_inode_attributes(struct inode *inode, struct nfs_fattr *fattr)
1666 {
1667 struct nfs_inode *nfsi = NFS_I(inode);
1668 loff_t cur_size, new_isize;
1669 unsigned long invalid = 0;
1670 struct timespec64 ts;
1671
1672 if (nfs_have_delegated_attributes(inode))
1673 return 0;
1674
1675 if (!(fattr->valid & NFS_ATTR_FATTR_FILEID)) {
1676 /* Only a mounted-on-fileid? Just exit */
1677 if (fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
1678 return 0;
1679 /* Has the inode gone and changed behind our back? */
1680 } else if (nfsi->fileid != fattr->fileid) {
1681 /* Is this perhaps the mounted-on fileid? */
1682 if ((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) &&
1683 nfsi->fileid == fattr->mounted_on_fileid)
1684 return 0;
1685 return -ESTALE;
1686 }
1687 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && inode_wrong_type(inode, fattr->mode))
1688 return -ESTALE;
1689
1690
1691 if (!nfs_file_has_buffered_writers(nfsi)) {
1692 /* Verify a few of the more important attributes */
1693 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 && !inode_eq_iversion_raw(inode, fattr->change_attr))
1694 invalid |= NFS_INO_INVALID_CHANGE;
1695
1696 ts = inode_get_mtime(inode);
1697 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) && !timespec64_equal(&ts, &fattr->mtime))
1698 invalid |= NFS_INO_INVALID_MTIME;
1699
1700 ts = inode_get_ctime(inode);
1701 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) && !timespec64_equal(&ts, &fattr->ctime))
1702 invalid |= NFS_INO_INVALID_CTIME;
1703
1704 if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
1705 cur_size = i_size_read(inode);
1706 new_isize = nfs_size_to_loff_t(fattr->size);
1707 if (cur_size != new_isize)
1708 invalid |= NFS_INO_INVALID_SIZE;
1709 }
1710 }
1711
1712 /* Have any file permissions changed? */
1713 if ((fattr->valid & NFS_ATTR_FATTR_MODE) && (inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO))
1714 invalid |= NFS_INO_INVALID_MODE;
1715 if ((fattr->valid & NFS_ATTR_FATTR_OWNER) && !uid_eq(inode->i_uid, fattr->uid))
1716 invalid |= NFS_INO_INVALID_OTHER;
1717 if ((fattr->valid & NFS_ATTR_FATTR_GROUP) && !gid_eq(inode->i_gid, fattr->gid))
1718 invalid |= NFS_INO_INVALID_OTHER;
1719
1720 /* Has the link count changed? */
1721 if ((fattr->valid & NFS_ATTR_FATTR_NLINK) && inode->i_nlink != fattr->nlink)
1722 invalid |= NFS_INO_INVALID_NLINK;
1723
1724 ts = inode_get_atime(inode);
1725 if ((fattr->valid & NFS_ATTR_FATTR_ATIME) && !timespec64_equal(&ts, &fattr->atime))
1726 invalid |= NFS_INO_INVALID_ATIME;
1727
1728 if (invalid != 0)
1729 nfs_set_cache_invalid(inode, invalid);
1730
1731 nfsi->read_cache_jiffies = fattr->time_start;
1732 return 0;
1733 }
1734
1735 static atomic_long_t nfs_attr_generation_counter;
1736
nfs_read_attr_generation_counter(void)1737 static unsigned long nfs_read_attr_generation_counter(void)
1738 {
1739 return atomic_long_read(&nfs_attr_generation_counter);
1740 }
1741
nfs_inc_attr_generation_counter(void)1742 unsigned long nfs_inc_attr_generation_counter(void)
1743 {
1744 return atomic_long_inc_return(&nfs_attr_generation_counter);
1745 }
1746 EXPORT_SYMBOL_GPL(nfs_inc_attr_generation_counter);
1747
nfs_fattr_init(struct nfs_fattr * fattr)1748 void nfs_fattr_init(struct nfs_fattr *fattr)
1749 {
1750 fattr->valid = 0;
1751 fattr->time_start = jiffies;
1752 fattr->gencount = nfs_inc_attr_generation_counter();
1753 fattr->owner_name = NULL;
1754 fattr->group_name = NULL;
1755 fattr->mdsthreshold = NULL;
1756 }
1757 EXPORT_SYMBOL_GPL(nfs_fattr_init);
1758
1759 /**
1760 * nfs_fattr_set_barrier
1761 * @fattr: attributes
1762 *
1763 * Used to set a barrier after an attribute was updated. This
1764 * barrier ensures that older attributes from RPC calls that may
1765 * have raced with our update cannot clobber these new values.
1766 * Note that you are still responsible for ensuring that other
1767 * operations which change the attribute on the server do not
1768 * collide.
1769 */
nfs_fattr_set_barrier(struct nfs_fattr * fattr)1770 void nfs_fattr_set_barrier(struct nfs_fattr *fattr)
1771 {
1772 fattr->gencount = nfs_inc_attr_generation_counter();
1773 }
1774
nfs_alloc_fattr(void)1775 struct nfs_fattr *nfs_alloc_fattr(void)
1776 {
1777 struct nfs_fattr *fattr;
1778
1779 fattr = kmalloc(sizeof(*fattr), GFP_KERNEL);
1780 if (fattr != NULL) {
1781 nfs_fattr_init(fattr);
1782 fattr->label = NULL;
1783 }
1784 return fattr;
1785 }
1786 EXPORT_SYMBOL_GPL(nfs_alloc_fattr);
1787
nfs_alloc_fattr_with_label(struct nfs_server * server)1788 struct nfs_fattr *nfs_alloc_fattr_with_label(struct nfs_server *server)
1789 {
1790 struct nfs_fattr *fattr = nfs_alloc_fattr();
1791
1792 if (!fattr)
1793 return NULL;
1794
1795 fattr->label = nfs4_label_alloc(server, GFP_KERNEL);
1796 if (IS_ERR(fattr->label)) {
1797 kfree(fattr);
1798 return NULL;
1799 }
1800
1801 return fattr;
1802 }
1803 EXPORT_SYMBOL_GPL(nfs_alloc_fattr_with_label);
1804
nfs_alloc_fhandle(void)1805 struct nfs_fh *nfs_alloc_fhandle(void)
1806 {
1807 struct nfs_fh *fh;
1808
1809 fh = kmalloc(sizeof(struct nfs_fh), GFP_KERNEL);
1810 if (fh != NULL)
1811 fh->size = 0;
1812 return fh;
1813 }
1814 EXPORT_SYMBOL_GPL(nfs_alloc_fhandle);
1815
1816 #ifdef NFS_DEBUG
1817 /*
1818 * _nfs_display_fhandle_hash - calculate the crc32 hash for the filehandle
1819 * in the same way that wireshark does
1820 *
1821 * @fh: file handle
1822 *
1823 * For debugging only.
1824 */
_nfs_display_fhandle_hash(const struct nfs_fh * fh)1825 u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh)
1826 {
1827 /* wireshark uses 32-bit AUTODIN crc and does a bitwise
1828 * not on the result */
1829 return nfs_fhandle_hash(fh);
1830 }
1831 EXPORT_SYMBOL_GPL(_nfs_display_fhandle_hash);
1832
1833 /*
1834 * _nfs_display_fhandle - display an NFS file handle on the console
1835 *
1836 * @fh: file handle to display
1837 * @caption: display caption
1838 *
1839 * For debugging only.
1840 */
_nfs_display_fhandle(const struct nfs_fh * fh,const char * caption)1841 void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption)
1842 {
1843 unsigned short i;
1844
1845 if (fh == NULL || fh->size == 0) {
1846 printk(KERN_DEFAULT "%s at %p is empty\n", caption, fh);
1847 return;
1848 }
1849
1850 printk(KERN_DEFAULT "%s at %p is %u bytes, crc: 0x%08x:\n",
1851 caption, fh, fh->size, _nfs_display_fhandle_hash(fh));
1852 for (i = 0; i < fh->size; i += 16) {
1853 __be32 *pos = (__be32 *)&fh->data[i];
1854
1855 switch ((fh->size - i - 1) >> 2) {
1856 case 0:
1857 printk(KERN_DEFAULT " %08x\n",
1858 be32_to_cpup(pos));
1859 break;
1860 case 1:
1861 printk(KERN_DEFAULT " %08x %08x\n",
1862 be32_to_cpup(pos), be32_to_cpup(pos + 1));
1863 break;
1864 case 2:
1865 printk(KERN_DEFAULT " %08x %08x %08x\n",
1866 be32_to_cpup(pos), be32_to_cpup(pos + 1),
1867 be32_to_cpup(pos + 2));
1868 break;
1869 default:
1870 printk(KERN_DEFAULT " %08x %08x %08x %08x\n",
1871 be32_to_cpup(pos), be32_to_cpup(pos + 1),
1872 be32_to_cpup(pos + 2), be32_to_cpup(pos + 3));
1873 }
1874 }
1875 }
1876 EXPORT_SYMBOL_GPL(_nfs_display_fhandle);
1877 #endif
1878
1879 /**
1880 * nfs_inode_attrs_cmp_generic - compare attributes
1881 * @fattr: attributes
1882 * @inode: pointer to inode
1883 *
1884 * Attempt to divine whether or not an RPC call reply carrying stale
1885 * attributes got scheduled after another call carrying updated ones.
1886 * Note also the check for wraparound of 'attr_gencount'
1887 *
1888 * The function returns '1' if it thinks the attributes in @fattr are
1889 * more recent than the ones cached in @inode. Otherwise it returns
1890 * the value '0'.
1891 */
nfs_inode_attrs_cmp_generic(const struct nfs_fattr * fattr,const struct inode * inode)1892 static int nfs_inode_attrs_cmp_generic(const struct nfs_fattr *fattr,
1893 const struct inode *inode)
1894 {
1895 unsigned long attr_gencount = NFS_I(inode)->attr_gencount;
1896
1897 return (long)(fattr->gencount - attr_gencount) > 0 ||
1898 (long)(attr_gencount - nfs_read_attr_generation_counter()) > 0;
1899 }
1900
1901 /**
1902 * nfs_inode_attrs_cmp_monotonic - compare attributes
1903 * @fattr: attributes
1904 * @inode: pointer to inode
1905 *
1906 * Attempt to divine whether or not an RPC call reply carrying stale
1907 * attributes got scheduled after another call carrying updated ones.
1908 *
1909 * We assume that the server observes monotonic semantics for
1910 * the change attribute, so a larger value means that the attributes in
1911 * @fattr are more recent, in which case the function returns the
1912 * value '1'.
1913 * A return value of '0' indicates no measurable change
1914 * A return value of '-1' means that the attributes in @inode are
1915 * more recent.
1916 */
nfs_inode_attrs_cmp_monotonic(const struct nfs_fattr * fattr,const struct inode * inode)1917 static int nfs_inode_attrs_cmp_monotonic(const struct nfs_fattr *fattr,
1918 const struct inode *inode)
1919 {
1920 s64 diff = fattr->change_attr - inode_peek_iversion_raw(inode);
1921 if (diff > 0)
1922 return 1;
1923 return diff == 0 ? 0 : -1;
1924 }
1925
1926 /**
1927 * nfs_inode_attrs_cmp_strict_monotonic - compare attributes
1928 * @fattr: attributes
1929 * @inode: pointer to inode
1930 *
1931 * Attempt to divine whether or not an RPC call reply carrying stale
1932 * attributes got scheduled after another call carrying updated ones.
1933 *
1934 * We assume that the server observes strictly monotonic semantics for
1935 * the change attribute, so a larger value means that the attributes in
1936 * @fattr are more recent, in which case the function returns the
1937 * value '1'.
1938 * A return value of '-1' means that the attributes in @inode are
1939 * more recent or unchanged.
1940 */
nfs_inode_attrs_cmp_strict_monotonic(const struct nfs_fattr * fattr,const struct inode * inode)1941 static int nfs_inode_attrs_cmp_strict_monotonic(const struct nfs_fattr *fattr,
1942 const struct inode *inode)
1943 {
1944 return nfs_inode_attrs_cmp_monotonic(fattr, inode) > 0 ? 1 : -1;
1945 }
1946
1947 /**
1948 * nfs_inode_attrs_cmp - compare attributes
1949 * @fattr: attributes
1950 * @inode: pointer to inode
1951 *
1952 * This function returns '1' if it thinks the attributes in @fattr are
1953 * more recent than the ones cached in @inode. It returns '-1' if
1954 * the attributes in @inode are more recent than the ones in @fattr,
1955 * and it returns 0 if not sure.
1956 */
nfs_inode_attrs_cmp(const struct nfs_fattr * fattr,const struct inode * inode)1957 static int nfs_inode_attrs_cmp(const struct nfs_fattr *fattr,
1958 const struct inode *inode)
1959 {
1960 if (nfs_inode_attrs_cmp_generic(fattr, inode) > 0)
1961 return 1;
1962 switch (NFS_SERVER(inode)->change_attr_type) {
1963 case NFS4_CHANGE_TYPE_IS_UNDEFINED:
1964 break;
1965 case NFS4_CHANGE_TYPE_IS_TIME_METADATA:
1966 if (!(fattr->valid & NFS_ATTR_FATTR_CHANGE))
1967 break;
1968 return nfs_inode_attrs_cmp_monotonic(fattr, inode);
1969 default:
1970 if (!(fattr->valid & NFS_ATTR_FATTR_CHANGE))
1971 break;
1972 return nfs_inode_attrs_cmp_strict_monotonic(fattr, inode);
1973 }
1974 return 0;
1975 }
1976
1977 /**
1978 * nfs_inode_finish_partial_attr_update - complete a previous inode update
1979 * @fattr: attributes
1980 * @inode: pointer to inode
1981 *
1982 * Returns '1' if the last attribute update left the inode cached
1983 * attributes in a partially unrevalidated state, and @fattr
1984 * matches the change attribute of that partial update.
1985 * Otherwise returns '0'.
1986 */
nfs_inode_finish_partial_attr_update(const struct nfs_fattr * fattr,const struct inode * inode)1987 static int nfs_inode_finish_partial_attr_update(const struct nfs_fattr *fattr,
1988 const struct inode *inode)
1989 {
1990 const unsigned long check_valid =
1991 NFS_INO_INVALID_ATIME | NFS_INO_INVALID_CTIME |
1992 NFS_INO_INVALID_MTIME | NFS_INO_INVALID_SIZE |
1993 NFS_INO_INVALID_BLOCKS | NFS_INO_INVALID_OTHER |
1994 NFS_INO_INVALID_NLINK | NFS_INO_INVALID_BTIME;
1995 unsigned long cache_validity = NFS_I(inode)->cache_validity;
1996 enum nfs4_change_attr_type ctype = NFS_SERVER(inode)->change_attr_type;
1997
1998 if (ctype != NFS4_CHANGE_TYPE_IS_UNDEFINED &&
1999 !(cache_validity & NFS_INO_INVALID_CHANGE) &&
2000 (cache_validity & check_valid) != 0 &&
2001 (fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
2002 nfs_inode_attrs_cmp_monotonic(fattr, inode) == 0)
2003 return 1;
2004 return 0;
2005 }
2006
nfs_ooo_merge(struct nfs_inode * nfsi,u64 start,u64 end)2007 static void nfs_ooo_merge(struct nfs_inode *nfsi,
2008 u64 start, u64 end)
2009 {
2010 int i, cnt;
2011
2012 if (nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER)
2013 /* No point merging anything */
2014 return;
2015
2016 if (!nfsi->ooo) {
2017 nfsi->ooo = kmalloc(sizeof(*nfsi->ooo), GFP_ATOMIC);
2018 if (!nfsi->ooo) {
2019 nfsi->cache_validity |= NFS_INO_DATA_INVAL_DEFER;
2020 return;
2021 }
2022 nfsi->ooo->cnt = 0;
2023 }
2024
2025 /* add this range, merging if possible */
2026 cnt = nfsi->ooo->cnt;
2027 for (i = 0; i < cnt; i++) {
2028 if (end == nfsi->ooo->gap[i].start)
2029 end = nfsi->ooo->gap[i].end;
2030 else if (start == nfsi->ooo->gap[i].end)
2031 start = nfsi->ooo->gap[i].start;
2032 else
2033 continue;
2034 /* Remove 'i' from table and loop to insert the new range */
2035 cnt -= 1;
2036 nfsi->ooo->gap[i] = nfsi->ooo->gap[cnt];
2037 i = -1;
2038 }
2039 if (start != end) {
2040 if (cnt >= ARRAY_SIZE(nfsi->ooo->gap)) {
2041 nfsi->cache_validity |= NFS_INO_DATA_INVAL_DEFER;
2042 kfree(nfsi->ooo);
2043 nfsi->ooo = NULL;
2044 return;
2045 }
2046 nfsi->ooo->gap[cnt].start = start;
2047 nfsi->ooo->gap[cnt].end = end;
2048 cnt += 1;
2049 }
2050 nfsi->ooo->cnt = cnt;
2051 }
2052
nfs_ooo_record(struct nfs_inode * nfsi,struct nfs_fattr * fattr)2053 static void nfs_ooo_record(struct nfs_inode *nfsi,
2054 struct nfs_fattr *fattr)
2055 {
2056 /* This reply was out-of-order, so record in the
2057 * pre/post change id, possibly cancelling
2058 * gaps created when iversion was jumpped forward.
2059 */
2060 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) &&
2061 (fattr->valid & NFS_ATTR_FATTR_PRECHANGE))
2062 nfs_ooo_merge(nfsi,
2063 fattr->change_attr,
2064 fattr->pre_change_attr);
2065 }
2066
nfs_refresh_inode_locked(struct inode * inode,struct nfs_fattr * fattr)2067 static int nfs_refresh_inode_locked(struct inode *inode,
2068 struct nfs_fattr *fattr)
2069 {
2070 int attr_cmp = nfs_inode_attrs_cmp(fattr, inode);
2071 int ret = 0;
2072
2073 trace_nfs_refresh_inode_enter(inode);
2074
2075 if (attr_cmp > 0 || nfs_inode_finish_partial_attr_update(fattr, inode))
2076 ret = nfs_update_inode(inode, fattr);
2077 else {
2078 nfs_ooo_record(NFS_I(inode), fattr);
2079
2080 if (attr_cmp == 0)
2081 ret = nfs_check_inode_attributes(inode, fattr);
2082 }
2083
2084 trace_nfs_refresh_inode_exit(inode, ret);
2085 return ret;
2086 }
2087
2088 /**
2089 * nfs_refresh_inode - try to update the inode attribute cache
2090 * @inode: pointer to inode
2091 * @fattr: updated attributes
2092 *
2093 * Check that an RPC call that returned attributes has not overlapped with
2094 * other recent updates of the inode metadata, then decide whether it is
2095 * safe to do a full update of the inode attributes, or whether just to
2096 * call nfs_check_inode_attributes.
2097 */
nfs_refresh_inode(struct inode * inode,struct nfs_fattr * fattr)2098 int nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
2099 {
2100 int status;
2101
2102 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
2103 return 0;
2104 spin_lock(&inode->i_lock);
2105 status = nfs_refresh_inode_locked(inode, fattr);
2106 spin_unlock(&inode->i_lock);
2107
2108 return status;
2109 }
2110 EXPORT_SYMBOL_GPL(nfs_refresh_inode);
2111
nfs_post_op_update_inode_locked(struct inode * inode,struct nfs_fattr * fattr,unsigned int invalid)2112 static int nfs_post_op_update_inode_locked(struct inode *inode,
2113 struct nfs_fattr *fattr, unsigned int invalid)
2114 {
2115 if (S_ISDIR(inode->i_mode))
2116 invalid |= NFS_INO_INVALID_DATA;
2117 nfs_set_cache_invalid(inode, invalid);
2118 if ((fattr->valid & NFS_ATTR_FATTR) == 0)
2119 return 0;
2120 return nfs_refresh_inode_locked(inode, fattr);
2121 }
2122
2123 /**
2124 * nfs_post_op_update_inode - try to update the inode attribute cache
2125 * @inode: pointer to inode
2126 * @fattr: updated attributes
2127 *
2128 * After an operation that has changed the inode metadata, mark the
2129 * attribute cache as being invalid, then try to update it.
2130 *
2131 * NB: if the server didn't return any post op attributes, this
2132 * function will force the retrieval of attributes before the next
2133 * NFS request. Thus it should be used only for operations that
2134 * are expected to change one or more attributes, to avoid
2135 * unnecessary NFS requests and trips through nfs_update_inode().
2136 */
nfs_post_op_update_inode(struct inode * inode,struct nfs_fattr * fattr)2137 int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr)
2138 {
2139 int status;
2140
2141 spin_lock(&inode->i_lock);
2142 nfs_fattr_set_barrier(fattr);
2143 status = nfs_post_op_update_inode_locked(inode, fattr,
2144 NFS_INO_INVALID_CHANGE
2145 | NFS_INO_INVALID_CTIME
2146 | NFS_INO_REVAL_FORCED);
2147 spin_unlock(&inode->i_lock);
2148
2149 return status;
2150 }
2151 EXPORT_SYMBOL_GPL(nfs_post_op_update_inode);
2152
2153 /**
2154 * nfs_post_op_update_inode_force_wcc_locked - update the inode attribute cache
2155 * @inode: pointer to inode
2156 * @fattr: updated attributes
2157 *
2158 * After an operation that has changed the inode metadata, mark the
2159 * attribute cache as being invalid, then try to update it. Fake up
2160 * weak cache consistency data, if none exist.
2161 *
2162 * This function is mainly designed to be used by the ->write_done() functions.
2163 */
nfs_post_op_update_inode_force_wcc_locked(struct inode * inode,struct nfs_fattr * fattr)2164 int nfs_post_op_update_inode_force_wcc_locked(struct inode *inode, struct nfs_fattr *fattr)
2165 {
2166 int attr_cmp = nfs_inode_attrs_cmp(fattr, inode);
2167 int status;
2168
2169 /* Don't do a WCC update if these attributes are already stale */
2170 if (attr_cmp < 0)
2171 return 0;
2172 if ((fattr->valid & NFS_ATTR_FATTR) == 0 || !attr_cmp) {
2173 /* Record the pre/post change info before clearing PRECHANGE */
2174 nfs_ooo_record(NFS_I(inode), fattr);
2175 fattr->valid &= ~(NFS_ATTR_FATTR_PRECHANGE
2176 | NFS_ATTR_FATTR_PRESIZE
2177 | NFS_ATTR_FATTR_PREMTIME
2178 | NFS_ATTR_FATTR_PRECTIME);
2179 goto out_noforce;
2180 }
2181 if ((fattr->valid & NFS_ATTR_FATTR_CHANGE) != 0 &&
2182 (fattr->valid & NFS_ATTR_FATTR_PRECHANGE) == 0) {
2183 fattr->pre_change_attr = inode_peek_iversion_raw(inode);
2184 fattr->valid |= NFS_ATTR_FATTR_PRECHANGE;
2185 }
2186 if ((fattr->valid & NFS_ATTR_FATTR_CTIME) != 0 &&
2187 (fattr->valid & NFS_ATTR_FATTR_PRECTIME) == 0) {
2188 fattr->pre_ctime = inode_get_ctime(inode);
2189 fattr->valid |= NFS_ATTR_FATTR_PRECTIME;
2190 }
2191 if ((fattr->valid & NFS_ATTR_FATTR_MTIME) != 0 &&
2192 (fattr->valid & NFS_ATTR_FATTR_PREMTIME) == 0) {
2193 fattr->pre_mtime = inode_get_mtime(inode);
2194 fattr->valid |= NFS_ATTR_FATTR_PREMTIME;
2195 }
2196 if ((fattr->valid & NFS_ATTR_FATTR_SIZE) != 0 &&
2197 (fattr->valid & NFS_ATTR_FATTR_PRESIZE) == 0) {
2198 fattr->pre_size = i_size_read(inode);
2199 fattr->valid |= NFS_ATTR_FATTR_PRESIZE;
2200 }
2201 out_noforce:
2202 status = nfs_post_op_update_inode_locked(inode, fattr,
2203 NFS_INO_INVALID_CHANGE
2204 | NFS_INO_INVALID_CTIME
2205 | NFS_INO_INVALID_MTIME
2206 | NFS_INO_INVALID_BLOCKS);
2207 return status;
2208 }
2209
2210 /**
2211 * nfs_post_op_update_inode_force_wcc - try to update the inode attribute cache
2212 * @inode: pointer to inode
2213 * @fattr: updated attributes
2214 *
2215 * After an operation that has changed the inode metadata, mark the
2216 * attribute cache as being invalid, then try to update it. Fake up
2217 * weak cache consistency data, if none exist.
2218 *
2219 * This function is mainly designed to be used by the ->write_done() functions.
2220 */
nfs_post_op_update_inode_force_wcc(struct inode * inode,struct nfs_fattr * fattr)2221 int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr)
2222 {
2223 int status;
2224
2225 spin_lock(&inode->i_lock);
2226 nfs_fattr_set_barrier(fattr);
2227 status = nfs_post_op_update_inode_force_wcc_locked(inode, fattr);
2228 spin_unlock(&inode->i_lock);
2229 return status;
2230 }
2231 EXPORT_SYMBOL_GPL(nfs_post_op_update_inode_force_wcc);
2232
2233
2234 /*
2235 * Many nfs protocol calls return the new file attributes after
2236 * an operation. Here we update the inode to reflect the state
2237 * of the server's inode.
2238 *
2239 * This is a bit tricky because we have to make sure all dirty pages
2240 * have been sent off to the server before calling invalidate_inode_pages.
2241 * To make sure no other process adds more write requests while we try
2242 * our best to flush them, we make them sleep during the attribute refresh.
2243 *
2244 * A very similar scenario holds for the dir cache.
2245 */
nfs_update_inode(struct inode * inode,struct nfs_fattr * fattr)2246 static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
2247 {
2248 struct nfs_server *server = NFS_SERVER(inode);
2249 struct nfs_inode *nfsi = NFS_I(inode);
2250 loff_t cur_isize, new_isize;
2251 u64 fattr_supported = server->fattr_valid;
2252 unsigned long invalid = 0;
2253 unsigned long now = jiffies;
2254 unsigned long save_cache_validity;
2255 bool have_writers = nfs_file_has_buffered_writers(nfsi);
2256 bool cache_revalidated = true;
2257 bool attr_changed = false;
2258 bool have_delegation;
2259
2260 dfprintk(VFS, "NFS: %s(%s/%lu fh_crc=0x%08x ct=%d info=0x%llx)\n",
2261 __func__, inode->i_sb->s_id, inode->i_ino,
2262 nfs_display_fhandle_hash(NFS_FH(inode)),
2263 icount_read(inode), fattr->valid);
2264
2265 if (!(fattr->valid & NFS_ATTR_FATTR_FILEID)) {
2266 /* Only a mounted-on-fileid? Just exit */
2267 if (fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID)
2268 return 0;
2269 /* Has the inode gone and changed behind our back? */
2270 } else if (nfsi->fileid != fattr->fileid) {
2271 /* Is this perhaps the mounted-on fileid? */
2272 if ((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) &&
2273 nfsi->fileid == fattr->mounted_on_fileid)
2274 return 0;
2275 printk(KERN_ERR "NFS: server %s error: fileid changed\n"
2276 "fsid %s: expected fileid 0x%Lx, got 0x%Lx\n",
2277 NFS_SERVER(inode)->nfs_client->cl_hostname,
2278 inode->i_sb->s_id, (long long)nfsi->fileid,
2279 (long long)fattr->fileid);
2280 goto out_err;
2281 }
2282
2283 /*
2284 * Make sure the inode's type hasn't changed.
2285 */
2286 if ((fattr->valid & NFS_ATTR_FATTR_TYPE) && inode_wrong_type(inode, fattr->mode)) {
2287 /*
2288 * Big trouble! The inode has become a different object.
2289 */
2290 printk(KERN_DEBUG "NFS: %s: inode %lu mode changed, %07o to %07o\n",
2291 __func__, inode->i_ino, inode->i_mode, fattr->mode);
2292 goto out_err;
2293 }
2294
2295 /* Update the fsid? */
2296 if (S_ISDIR(inode->i_mode) && (fattr->valid & NFS_ATTR_FATTR_FSID) &&
2297 !nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
2298 !IS_AUTOMOUNT(inode))
2299 server->fsid = fattr->fsid;
2300
2301 /* Save the delegation state before clearing cache_validity */
2302 have_delegation = nfs_have_delegated_attributes(inode);
2303
2304 /*
2305 * Update the read time so we don't revalidate too often.
2306 */
2307 nfsi->read_cache_jiffies = fattr->time_start;
2308
2309 /* Fix up any delegated attributes in the struct nfs_fattr */
2310 nfs_fattr_fixup_delegated(inode, fattr);
2311
2312 save_cache_validity = nfsi->cache_validity;
2313 nfsi->cache_validity &= ~(NFS_INO_INVALID_ATTR
2314 | NFS_INO_INVALID_ATIME
2315 | NFS_INO_REVAL_FORCED
2316 | NFS_INO_INVALID_BLOCKS);
2317
2318 /* Do atomic weak cache consistency updates */
2319 nfs_wcc_update_inode(inode, fattr);
2320
2321 if (pnfs_layoutcommit_outstanding(inode)) {
2322 nfsi->cache_validity |=
2323 save_cache_validity &
2324 (NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_CTIME |
2325 NFS_INO_INVALID_MTIME | NFS_INO_INVALID_SIZE |
2326 NFS_INO_INVALID_BLOCKS);
2327 cache_revalidated = false;
2328 }
2329
2330 /* More cache consistency checks */
2331 if (fattr->valid & NFS_ATTR_FATTR_CHANGE) {
2332 if (!have_writers && nfsi->ooo && nfsi->ooo->cnt == 1 &&
2333 nfsi->ooo->gap[0].end == inode_peek_iversion_raw(inode)) {
2334 /* There is one remaining gap that hasn't been
2335 * merged into iversion - do that now.
2336 */
2337 inode_set_iversion_raw(inode, nfsi->ooo->gap[0].start);
2338 kfree(nfsi->ooo);
2339 nfsi->ooo = NULL;
2340 }
2341 if (!inode_eq_iversion_raw(inode, fattr->change_attr)) {
2342 /* Could it be a race with writeback? */
2343 if (!(have_writers || have_delegation)) {
2344 invalid |= NFS_INO_INVALID_DATA
2345 | NFS_INO_INVALID_ACCESS
2346 | NFS_INO_INVALID_ACL
2347 | NFS_INO_INVALID_XATTR;
2348 /* Force revalidate of all attributes */
2349 save_cache_validity |= NFS_INO_INVALID_CTIME
2350 | NFS_INO_INVALID_MTIME
2351 | NFS_INO_INVALID_SIZE
2352 | NFS_INO_INVALID_BLOCKS
2353 | NFS_INO_INVALID_NLINK
2354 | NFS_INO_INVALID_MODE
2355 | NFS_INO_INVALID_OTHER
2356 | NFS_INO_INVALID_BTIME;
2357 if (S_ISDIR(inode->i_mode))
2358 nfs_force_lookup_revalidate(inode);
2359 attr_changed = true;
2360 dprintk("NFS: change_attr change on server for file %s/%ld\n",
2361 inode->i_sb->s_id,
2362 inode->i_ino);
2363 } else if (!have_delegation) {
2364 nfs_ooo_record(nfsi, fattr);
2365 nfs_ooo_merge(nfsi, inode_peek_iversion_raw(inode),
2366 fattr->change_attr);
2367 }
2368 inode_set_iversion_raw(inode, fattr->change_attr);
2369 }
2370 } else {
2371 nfsi->cache_validity |=
2372 save_cache_validity & NFS_INO_INVALID_CHANGE;
2373 if (!have_delegation ||
2374 (nfsi->cache_validity & NFS_INO_INVALID_CHANGE) != 0)
2375 cache_revalidated = false;
2376 }
2377
2378 if (fattr->valid & NFS_ATTR_FATTR_MTIME)
2379 inode_set_mtime_to_ts(inode, fattr->mtime);
2380 else if (fattr_supported & NFS_ATTR_FATTR_MTIME)
2381 nfsi->cache_validity |=
2382 save_cache_validity & NFS_INO_INVALID_MTIME;
2383
2384 if (fattr->valid & NFS_ATTR_FATTR_CTIME)
2385 inode_set_ctime_to_ts(inode, fattr->ctime);
2386 else if (fattr_supported & NFS_ATTR_FATTR_CTIME)
2387 nfsi->cache_validity |=
2388 save_cache_validity & NFS_INO_INVALID_CTIME;
2389
2390 if (fattr->valid & NFS_ATTR_FATTR_BTIME)
2391 nfsi->btime = fattr->btime;
2392 else if (fattr_supported & NFS_ATTR_FATTR_BTIME)
2393 nfsi->cache_validity |=
2394 save_cache_validity & NFS_INO_INVALID_BTIME;
2395
2396 /* Check if our cached file size is stale */
2397 if (fattr->valid & NFS_ATTR_FATTR_SIZE) {
2398 new_isize = nfs_size_to_loff_t(fattr->size);
2399 cur_isize = i_size_read(inode);
2400 if (new_isize != cur_isize && !have_delegation) {
2401 /* Do we perhaps have any outstanding writes, or has
2402 * the file grown beyond our last write? */
2403 if (!nfs_have_writebacks(inode) || new_isize > cur_isize) {
2404 trace_nfs_size_update(inode, new_isize);
2405 i_size_write(inode, new_isize);
2406 if (!have_writers)
2407 invalid |= NFS_INO_INVALID_DATA;
2408 }
2409 }
2410 if (new_isize == 0 &&
2411 !(fattr->valid & (NFS_ATTR_FATTR_SPACE_USED |
2412 NFS_ATTR_FATTR_BLOCKS_USED))) {
2413 fattr->du.nfs3.used = 0;
2414 fattr->valid |= NFS_ATTR_FATTR_SPACE_USED;
2415 }
2416 } else
2417 nfsi->cache_validity |=
2418 save_cache_validity & NFS_INO_INVALID_SIZE;
2419
2420 if (fattr->valid & NFS_ATTR_FATTR_ATIME)
2421 inode_set_atime_to_ts(inode, fattr->atime);
2422 else if (fattr_supported & NFS_ATTR_FATTR_ATIME)
2423 nfsi->cache_validity |=
2424 save_cache_validity & NFS_INO_INVALID_ATIME;
2425
2426 if (fattr->valid & NFS_ATTR_FATTR_MODE) {
2427 if ((inode->i_mode & S_IALLUGO) != (fattr->mode & S_IALLUGO)) {
2428 umode_t newmode = inode->i_mode & S_IFMT;
2429 newmode |= fattr->mode & S_IALLUGO;
2430 inode->i_mode = newmode;
2431 invalid |= NFS_INO_INVALID_ACCESS
2432 | NFS_INO_INVALID_ACL;
2433 }
2434 } else if (fattr_supported & NFS_ATTR_FATTR_MODE)
2435 nfsi->cache_validity |=
2436 save_cache_validity & NFS_INO_INVALID_MODE;
2437
2438 if (fattr->valid & NFS_ATTR_FATTR_OWNER) {
2439 if (!uid_eq(inode->i_uid, fattr->uid)) {
2440 invalid |= NFS_INO_INVALID_ACCESS
2441 | NFS_INO_INVALID_ACL;
2442 inode->i_uid = fattr->uid;
2443 }
2444 } else if (fattr_supported & NFS_ATTR_FATTR_OWNER)
2445 nfsi->cache_validity |=
2446 save_cache_validity & NFS_INO_INVALID_OTHER;
2447
2448 if (fattr->valid & NFS_ATTR_FATTR_GROUP) {
2449 if (!gid_eq(inode->i_gid, fattr->gid)) {
2450 invalid |= NFS_INO_INVALID_ACCESS
2451 | NFS_INO_INVALID_ACL;
2452 inode->i_gid = fattr->gid;
2453 }
2454 } else if (fattr_supported & NFS_ATTR_FATTR_GROUP)
2455 nfsi->cache_validity |=
2456 save_cache_validity & NFS_INO_INVALID_OTHER;
2457
2458 if (fattr->valid & NFS_ATTR_FATTR_NLINK) {
2459 if (inode->i_nlink != fattr->nlink)
2460 set_nlink(inode, fattr->nlink);
2461 } else if (fattr_supported & NFS_ATTR_FATTR_NLINK)
2462 nfsi->cache_validity |=
2463 save_cache_validity & NFS_INO_INVALID_NLINK;
2464
2465 if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
2466 /*
2467 * report the blocks in 512byte units
2468 */
2469 inode->i_blocks = nfs_calc_block_size(fattr->du.nfs3.used);
2470 } else if (fattr_supported & NFS_ATTR_FATTR_SPACE_USED)
2471 nfsi->cache_validity |=
2472 save_cache_validity & NFS_INO_INVALID_BLOCKS;
2473
2474 if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
2475 inode->i_blocks = fattr->du.nfs2.blocks;
2476 else if (fattr_supported & NFS_ATTR_FATTR_BLOCKS_USED)
2477 nfsi->cache_validity |=
2478 save_cache_validity & NFS_INO_INVALID_BLOCKS;
2479
2480 /* Update attrtimeo value if we're out of the unstable period */
2481 if (attr_changed) {
2482 nfs_inc_stats(inode, NFSIOS_ATTRINVALIDATE);
2483 nfsi->attrtimeo = NFS_MINATTRTIMEO(inode);
2484 nfsi->attrtimeo_timestamp = now;
2485 /* Set barrier to be more recent than all outstanding updates */
2486 nfsi->attr_gencount = nfs_inc_attr_generation_counter();
2487 } else {
2488 if (cache_revalidated) {
2489 if (!time_in_range_open(now, nfsi->attrtimeo_timestamp,
2490 nfsi->attrtimeo_timestamp + nfsi->attrtimeo)) {
2491 nfsi->attrtimeo <<= 1;
2492 if (nfsi->attrtimeo > NFS_MAXATTRTIMEO(inode))
2493 nfsi->attrtimeo = NFS_MAXATTRTIMEO(inode);
2494 }
2495 nfsi->attrtimeo_timestamp = now;
2496 }
2497 /* Set the barrier to be more recent than this fattr */
2498 if ((long)(fattr->gencount - nfsi->attr_gencount) > 0)
2499 nfsi->attr_gencount = fattr->gencount;
2500 }
2501
2502 /* Don't invalidate the data if we were to blame */
2503 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
2504 || S_ISLNK(inode->i_mode)))
2505 invalid &= ~NFS_INO_INVALID_DATA;
2506 nfs_set_cache_invalid(inode, invalid);
2507
2508 return 0;
2509 out_err:
2510 /*
2511 * No need to worry about unhashing the dentry, as the
2512 * lookup validation will know that the inode is bad.
2513 * (But we fall through to invalidate the caches.)
2514 */
2515 nfs_set_inode_stale_locked(inode);
2516 return -ESTALE;
2517 }
2518
nfs_alloc_inode(struct super_block * sb)2519 struct inode *nfs_alloc_inode(struct super_block *sb)
2520 {
2521 struct nfs_inode *nfsi;
2522 nfsi = alloc_inode_sb(sb, nfs_inode_cachep, GFP_KERNEL);
2523 if (!nfsi)
2524 return NULL;
2525 nfsi->flags = 0UL;
2526 nfsi->cache_validity = 0UL;
2527 nfsi->ooo = NULL;
2528 #if IS_ENABLED(CONFIG_NFS_V4)
2529 nfsi->nfs4_acl = NULL;
2530 #endif /* CONFIG_NFS_V4 */
2531 #ifdef CONFIG_NFS_V4_2
2532 nfsi->xattr_cache = NULL;
2533 #endif
2534 nfs_netfs_inode_init(nfsi);
2535
2536 return &nfsi->vfs_inode;
2537 }
2538 EXPORT_SYMBOL_GPL(nfs_alloc_inode);
2539
nfs_free_inode(struct inode * inode)2540 void nfs_free_inode(struct inode *inode)
2541 {
2542 kfree(NFS_I(inode)->ooo);
2543 kmem_cache_free(nfs_inode_cachep, NFS_I(inode));
2544 }
2545 EXPORT_SYMBOL_GPL(nfs_free_inode);
2546
nfs4_init_once(struct nfs_inode * nfsi)2547 static inline void nfs4_init_once(struct nfs_inode *nfsi)
2548 {
2549 #if IS_ENABLED(CONFIG_NFS_V4)
2550 INIT_LIST_HEAD(&nfsi->open_states);
2551 nfsi->delegation = NULL;
2552 init_rwsem(&nfsi->rwsem);
2553 nfsi->layout = NULL;
2554 #endif
2555 }
2556
init_once(void * foo)2557 static void init_once(void *foo)
2558 {
2559 struct nfs_inode *nfsi = foo;
2560
2561 inode_init_once(&nfsi->vfs_inode);
2562 INIT_LIST_HEAD(&nfsi->open_files);
2563 INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
2564 INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
2565 nfs4_init_once(nfsi);
2566 }
2567
nfs_init_inodecache(void)2568 static int __init nfs_init_inodecache(void)
2569 {
2570 nfs_inode_cachep = kmem_cache_create("nfs_inode_cache",
2571 sizeof(struct nfs_inode),
2572 0, (SLAB_RECLAIM_ACCOUNT|
2573 SLAB_ACCOUNT),
2574 init_once);
2575 if (nfs_inode_cachep == NULL)
2576 return -ENOMEM;
2577
2578 return 0;
2579 }
2580
nfs_destroy_inodecache(void)2581 static void nfs_destroy_inodecache(void)
2582 {
2583 /*
2584 * Make sure all delayed rcu free inodes are flushed before we
2585 * destroy cache.
2586 */
2587 rcu_barrier();
2588 kmem_cache_destroy(nfs_inode_cachep);
2589 }
2590
2591 struct workqueue_struct *nfslocaliod_workqueue;
2592 struct workqueue_struct *nfsiod_workqueue;
2593 EXPORT_SYMBOL_GPL(nfsiod_workqueue);
2594
2595 /*
2596 * Destroy the nfsiod workqueues
2597 */
nfsiod_stop(void)2598 static void nfsiod_stop(void)
2599 {
2600 struct workqueue_struct *wq;
2601
2602 wq = nfsiod_workqueue;
2603 if (wq != NULL) {
2604 nfsiod_workqueue = NULL;
2605 destroy_workqueue(wq);
2606 }
2607 #if IS_ENABLED(CONFIG_NFS_LOCALIO)
2608 wq = nfslocaliod_workqueue;
2609 if (wq != NULL) {
2610 nfslocaliod_workqueue = NULL;
2611 destroy_workqueue(wq);
2612 }
2613 #endif /* CONFIG_NFS_LOCALIO */
2614 }
2615
2616 /*
2617 * Start the nfsiod workqueues
2618 */
nfsiod_start(void)2619 static int nfsiod_start(void)
2620 {
2621 dprintk("RPC: creating workqueue nfsiod\n");
2622 nfsiod_workqueue = alloc_workqueue("nfsiod", WQ_MEM_RECLAIM | WQ_UNBOUND, 0);
2623 if (nfsiod_workqueue == NULL)
2624 return -ENOMEM;
2625 #if IS_ENABLED(CONFIG_NFS_LOCALIO)
2626 /*
2627 * localio writes need to use a normal (non-memreclaim) workqueue.
2628 * When we start getting low on space, XFS goes and calls flush_work() on
2629 * a non-memreclaim work queue, which causes a priority inversion problem.
2630 */
2631 dprintk("RPC: creating workqueue nfslocaliod\n");
2632 nfslocaliod_workqueue = alloc_workqueue("nfslocaliod", WQ_UNBOUND, 0);
2633 if (unlikely(nfslocaliod_workqueue == NULL)) {
2634 nfsiod_stop();
2635 return -ENOMEM;
2636 }
2637 #endif /* CONFIG_NFS_LOCALIO */
2638 return 0;
2639 }
2640
2641 unsigned int nfs_net_id;
2642 EXPORT_SYMBOL_GPL(nfs_net_id);
2643
nfs_net_init(struct net * net)2644 static int nfs_net_init(struct net *net)
2645 {
2646 struct nfs_net *nn = net_generic(net, nfs_net_id);
2647 int err;
2648
2649 nfs_clients_init(net);
2650
2651 if (!rpc_proc_register(net, &nn->rpcstats)) {
2652 err = -ENOMEM;
2653 goto err_proc_rpc;
2654 }
2655
2656 err = nfs_fs_proc_net_init(net);
2657 if (err)
2658 goto err_proc_nfs;
2659
2660 return 0;
2661
2662 err_proc_nfs:
2663 rpc_proc_unregister(net, "nfs");
2664 err_proc_rpc:
2665 nfs_clients_exit(net);
2666 return err;
2667 }
2668
nfs_net_exit(struct net * net)2669 static void nfs_net_exit(struct net *net)
2670 {
2671 rpc_proc_unregister(net, "nfs");
2672 nfs_fs_proc_net_exit(net);
2673 nfs_clients_exit(net);
2674 }
2675
2676 static struct pernet_operations nfs_net_ops = {
2677 .init = nfs_net_init,
2678 .exit = nfs_net_exit,
2679 .id = &nfs_net_id,
2680 .size = sizeof(struct nfs_net),
2681 };
2682
2683 #ifdef CONFIG_KEYS
2684 static struct key *nfs_keyring;
2685
nfs_init_keyring(void)2686 static int __init nfs_init_keyring(void)
2687 {
2688 nfs_keyring = keyring_alloc(".nfs",
2689 GLOBAL_ROOT_UID, GLOBAL_ROOT_GID,
2690 current_cred(),
2691 (KEY_POS_ALL & ~KEY_POS_SETATTR) |
2692 (KEY_USR_ALL & ~KEY_USR_SETATTR),
2693 KEY_ALLOC_NOT_IN_QUOTA, NULL, NULL);
2694 return PTR_ERR_OR_ZERO(nfs_keyring);
2695 }
2696
nfs_exit_keyring(void)2697 static void nfs_exit_keyring(void)
2698 {
2699 key_put(nfs_keyring);
2700 }
2701 #else
nfs_init_keyring(void)2702 static inline int nfs_init_keyring(void)
2703 {
2704 return 0;
2705 }
2706
nfs_exit_keyring(void)2707 static inline void nfs_exit_keyring(void)
2708 {
2709 }
2710 #endif /* CONFIG_KEYS */
2711
2712 /*
2713 * Initialize NFS
2714 */
init_nfs_fs(void)2715 static int __init init_nfs_fs(void)
2716 {
2717 int err;
2718
2719 err = nfs_init_keyring();
2720 if (err)
2721 return err;
2722
2723 err = nfs_sysfs_init();
2724 if (err < 0)
2725 goto out10;
2726
2727 err = register_pernet_subsys(&nfs_net_ops);
2728 if (err < 0)
2729 goto out9;
2730
2731 err = nfsiod_start();
2732 if (err)
2733 goto out7;
2734
2735 err = nfs_fs_proc_init();
2736 if (err)
2737 goto out6;
2738
2739 err = nfs_init_nfspagecache();
2740 if (err)
2741 goto out5;
2742
2743 err = nfs_init_inodecache();
2744 if (err)
2745 goto out4;
2746
2747 err = nfs_init_readpagecache();
2748 if (err)
2749 goto out3;
2750
2751 err = nfs_init_writepagecache();
2752 if (err)
2753 goto out2;
2754
2755 err = nfs_init_directcache();
2756 if (err)
2757 goto out1;
2758
2759 err = register_nfs_fs();
2760 if (err)
2761 goto out0;
2762
2763 return 0;
2764 out0:
2765 nfs_destroy_directcache();
2766 out1:
2767 nfs_destroy_writepagecache();
2768 out2:
2769 nfs_destroy_readpagecache();
2770 out3:
2771 nfs_destroy_inodecache();
2772 out4:
2773 nfs_destroy_nfspagecache();
2774 out5:
2775 nfs_fs_proc_exit();
2776 out6:
2777 nfsiod_stop();
2778 out7:
2779 unregister_pernet_subsys(&nfs_net_ops);
2780 out9:
2781 nfs_sysfs_exit();
2782 out10:
2783 nfs_exit_keyring();
2784 return err;
2785 }
2786
exit_nfs_fs(void)2787 static void __exit exit_nfs_fs(void)
2788 {
2789 nfs_destroy_directcache();
2790 nfs_destroy_writepagecache();
2791 nfs_destroy_readpagecache();
2792 nfs_destroy_inodecache();
2793 nfs_destroy_nfspagecache();
2794 unregister_pernet_subsys(&nfs_net_ops);
2795 unregister_nfs_fs();
2796 nfs_fs_proc_exit();
2797 nfsiod_stop();
2798 nfs_sysfs_exit();
2799 nfs_exit_keyring();
2800 }
2801
2802 /* Not quite true; I just maintain it */
2803 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");
2804 MODULE_DESCRIPTION("NFS client support");
2805 MODULE_LICENSE("GPL");
2806 module_param(enable_ino64, bool, 0644);
2807
2808 module_init(init_nfs_fs)
2809 module_exit(exit_nfs_fs)
2810